[PATCH v6 00/11] Show privacy_gpio as a v4l2_ctrl

[PATCH v6 00/11] Show privacy_gpio as a v4l2_ctrl

[Ricardo Ribalda]

Some devices can implement a physical switch to disable the input of the
camera on demand. Think of it like an elegant privacy sticker.

The system can read the status of the privacy switch via a GPIO.

The ACPI table maps this GPIO to the USB device via _CRS and _DSD
descriptors, so the kernel can find it.

The userspace applications need to know if the privacy pin is enabled
or not.

The obvious way to show it to userspace is via the V4L2_CID_PRIVACY
control.

This patchset implement this functionality.

v6: Thanks to all the comments from Laurent!
  - Remove multiple async_ctrls from v5, it is not needed
  - Split event handling in two parts, so it can be triggered without wq
  - Save pointer to the privacy entity in the main structure
  - Handle the quirk in a different location to avoid races
  - CodeStyle

v5: Thanks to all the comments from Laurent!
  - Allow multiple async_ctrls
  - Use dev_dbg() for uvc_trace
  - Major redesing of "Implement UVC_EXT_GPIO_UNIT"
  - Major redesing of "Implement UVC_QUIRK_PRIVACY_DURING_STREAM"

v4: Implement UVC_QUIRK_PRIVACY_DURING_STREAM

v3: Thanks to all the comments from Joe Perches
  - Rework of printk macros

v2: Thanks to all the comments from Laurent!
  - move guid to unit
  - support entities with no pads
  - CodeStyle
  - Irq handling
  - pr_cont
  - new ids

Ricardo Ribalda (11):
  media: uvcvideo: Move guid to entity
  media: uvcvideo: Allow extra entities
  media: uvcvideo: Allow entities with no pads
  media: uvcvideo: Add uvc_ctrl_status_event_direct
  media: uvcvideo: Allow entity-defined get_info and get_cur
  media: uvcvideo: Implement UVC_EXT_GPIO_UNIT
  media: uvcvideo: Add Privacy control based on EXT_GPIO
  media: uvcvideo: Implement UVC_QUIRK_PRIVACY_DURING_STREAM
  media: uvcvideo: Use dev_ printk aliases
  media: uvcvideo: New macro uvc_trace_cont
  media: uvcvideo: use dev_printk() for uvc_trace()

 drivers/media/usb/uvc/uvc_ctrl.c   | 184 +++++----
 drivers/media/usb/uvc/uvc_driver.c | 603 +++++++++++++++++++----------
 drivers/media/usb/uvc/uvc_entity.c |  11 +-
 drivers/media/usb/uvc/uvc_isight.c |  16 +-
 drivers/media/usb/uvc/uvc_queue.c  |   9 +-
 drivers/media/usb/uvc/uvc_status.c |  32 +-
 drivers/media/usb/uvc/uvc_v4l2.c   |  53 ++-
 drivers/media/usb/uvc/uvc_video.c  | 147 ++++---
 drivers/media/usb/uvc/uvcvideo.h   |  76 +++-
 9 files changed, 727 insertions(+), 404 deletions(-)

-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 01/11] media: uvcvideo: Move guid to entity

[Ricardo Ribalda]

Instead of having multiple copies of the entity guid on the code, move
it to the entity structure.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c   | 30 ++++--------------------------
 drivers/media/usb/uvc/uvc_driver.c | 25 +++++++++++++++++++++++--
 drivers/media/usb/uvc/uvcvideo.h   |  2 +-
 3 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index 011e69427b7c..9f6174a10e73 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -826,31 +826,10 @@ static void uvc_set_le_value(struct uvc_control_mapping *mapping,
  * Terminal and unit management
  */
 
-static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
-static const u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
-static const u8 uvc_media_transport_input_guid[16] =
-	UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
-
 static int uvc_entity_match_guid(const struct uvc_entity *entity,
-	const u8 guid[16])
+				 const u8 guid[16])
 {
-	switch (UVC_ENTITY_TYPE(entity)) {
-	case UVC_ITT_CAMERA:
-		return memcmp(uvc_camera_guid, guid, 16) == 0;
-
-	case UVC_ITT_MEDIA_TRANSPORT_INPUT:
-		return memcmp(uvc_media_transport_input_guid, guid, 16) == 0;
-
-	case UVC_VC_PROCESSING_UNIT:
-		return memcmp(uvc_processing_guid, guid, 16) == 0;
-
-	case UVC_VC_EXTENSION_UNIT:
-		return memcmp(entity->extension.guidExtensionCode,
-			      guid, 16) == 0;
-
-	default:
-		return 0;
-	}
+	return memcmp(entity->guid, guid, sizeof(entity->guid)) == 0;
 }
 
 /* ------------------------------------------------------------------------
@@ -1776,8 +1755,7 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 	if (data == NULL)
 		return -ENOMEM;
 
-	memcpy(info->entity, ctrl->entity->extension.guidExtensionCode,
-	       sizeof(info->entity));
+	memcpy(info->entity, ctrl->entity->guid, sizeof(info->entity));
 	info->index = ctrl->index;
 	info->selector = ctrl->index + 1;
 
@@ -1883,7 +1861,7 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
 
 	if (!found) {
 		uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u not found.\n",
-			entity->extension.guidExtensionCode, xqry->selector);
+			entity->guid, xqry->selector);
 		return -ENOENT;
 	}
 
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index ddb9eaa11be7..bfbc5a4d4ca6 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1019,6 +1019,11 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	return ret;
 }
 
+static const u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
+static const u8 uvc_media_transport_input_guid[16] =
+	UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
+static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
+
 static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
 		unsigned int num_pads, unsigned int extra_size)
 {
@@ -1038,6 +1043,22 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
 	entity->id = id;
 	entity->type = type;
 
+	/*
+	 * Set the GUID for standard entity types. For extension units, the GUID
+	 * is initialized by the caller.
+	 */
+	switch (type) {
+	case UVC_ITT_CAMERA:
+		memcpy(entity->guid, uvc_camera_guid, 16);
+		break;
+	case UVC_ITT_MEDIA_TRANSPORT_INPUT:
+		memcpy(entity->guid, uvc_media_transport_input_guid, 16);
+		break;
+	case UVC_VC_PROCESSING_UNIT:
+		memcpy(entity->guid, uvc_processing_guid, 16);
+		break;
+	}
+
 	entity->num_links = 0;
 	entity->num_pads = num_pads;
 	entity->pads = ((void *)(entity + 1)) + extra_size;
@@ -1109,7 +1130,7 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
 		if (unit == NULL)
 			return -ENOMEM;
 
-		memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
+		memcpy(unit->guid, &buffer[4], 16);
 		unit->extension.bNumControls = buffer[20];
 		memcpy(unit->baSourceID, &buffer[22], p);
 		unit->extension.bControlSize = buffer[22+p];
@@ -1368,7 +1389,7 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		if (unit == NULL)
 			return -ENOMEM;
 
-		memcpy(unit->extension.guidExtensionCode, &buffer[4], 16);
+		memcpy(unit->guid, &buffer[4], 16);
 		unit->extension.bNumControls = buffer[20];
 		memcpy(unit->baSourceID, &buffer[22], p);
 		unit->extension.bControlSize = buffer[22+p];
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index a3dfacf069c4..df7bf2d104a3 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -304,6 +304,7 @@ struct uvc_entity {
 	u8 id;
 	u16 type;
 	char name[64];
+	u8 guid[16];
 
 	/* Media controller-related fields. */
 	struct video_device *vdev;
@@ -342,7 +343,6 @@ struct uvc_entity {
 		} selector;
 
 		struct {
-			u8  guidExtensionCode[16];
 			u8  bNumControls;
 			u8  bControlSize;
 			u8  *bmControls;
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 02/11] media: uvcvideo: Allow extra entities

[Ricardo Ribalda]

Increase the size of the id, to avoid collisions with entities
implemented by the driver that are not part of the UVC device.

Entities exposed by the UVC device use IDs 0-255, extra entities
implemented by the driver (such as the GPIO entity) use IDs 256 and
up.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_driver.c | 2 +-
 drivers/media/usb/uvc/uvcvideo.h   | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index bfbc5a4d4ca6..82cdd1bb28dc 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1024,7 +1024,7 @@ static const u8 uvc_media_transport_input_guid[16] =
 	UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
 static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
 
-static struct uvc_entity *uvc_alloc_entity(u16 type, u8 id,
+static struct uvc_entity *uvc_alloc_entity(u16 type, u16 id,
 		unsigned int num_pads, unsigned int extra_size)
 {
 	struct uvc_entity *entity;
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index df7bf2d104a3..c50b0546901f 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -301,7 +301,12 @@ struct uvc_entity {
 					 * chain. */
 	unsigned int flags;
 
-	u8 id;
+	/*
+	 * Entities exposed by the UVC device use IDs 0-255, extra entities
+	 * implemented by the driver (such as the GPIO entity) use IDs 256 and
+	 * up.
+	 */
+	u16 id;
 	u16 type;
 	char name[64];
 	u8 guid[16];
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 03/11] media: uvcvideo: Allow entities with no pads

[Ricardo Ribalda]

Avoid an underflow while calculating the number of inputs for entities
with zero pads.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_driver.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 82cdd1bb28dc..c0c5f75ade40 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1033,7 +1033,10 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u16 id,
 	unsigned int i;
 
 	extra_size = roundup(extra_size, sizeof(*entity->pads));
-	num_inputs = (type & UVC_TERM_OUTPUT) ? num_pads : num_pads - 1;
+	if (num_pads)
+		num_inputs = type & UVC_TERM_OUTPUT ? num_pads : num_pads - 1;
+	else
+		num_inputs = 0;
 	size = sizeof(*entity) + extra_size + sizeof(*entity->pads) * num_pads
 	     + num_inputs;
 	entity = kzalloc(size, GFP_KERNEL);
@@ -1065,7 +1068,7 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u16 id,
 
 	for (i = 0; i < num_inputs; ++i)
 		entity->pads[i].flags = MEDIA_PAD_FL_SINK;
-	if (!UVC_ENTITY_IS_OTERM(entity))
+	if (!UVC_ENTITY_IS_OTERM(entity) && num_pads)
 		entity->pads[num_pads-1].flags = MEDIA_PAD_FL_SOURCE;
 
 	entity->bNrInPins = num_inputs;
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 04/11] media: uvcvideo: Add uvc_ctrl_status_event_direct

[Ricardo Ribalda]

Provide a code path for events that can be sent without a work-queue,
this is, that do not belong to an URB and are not handled in the top
half on an irq-handled.

Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c | 35 +++++++++++++++++++++++++++-----
 drivers/media/usb/uvc/uvcvideo.h |  2 ++
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index 9f6174a10e73..5fe228a3213b 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -1254,17 +1254,14 @@ static void uvc_ctrl_send_slave_event(struct uvc_video_chain *chain,
 	uvc_ctrl_send_event(chain, handle, ctrl, mapping, val, changes);
 }
 
-static void uvc_ctrl_status_event_work(struct work_struct *work)
+static void __uvc_ctrl_status_event(struct uvc_device *dev,
+				    struct uvc_ctrl_work *w)
 {
-	struct uvc_device *dev = container_of(work, struct uvc_device,
-					      async_ctrl.work);
-	struct uvc_ctrl_work *w = &dev->async_ctrl;
 	struct uvc_video_chain *chain = w->chain;
 	struct uvc_control_mapping *mapping;
 	struct uvc_control *ctrl = w->ctrl;
 	struct uvc_fh *handle;
 	unsigned int i;
-	int ret;
 
 	mutex_lock(&chain->ctrl_mutex);
 
@@ -1291,6 +1288,16 @@ static void uvc_ctrl_status_event_work(struct work_struct *work)
 	}
 
 	mutex_unlock(&chain->ctrl_mutex);
+}
+
+static void uvc_ctrl_status_event_work(struct work_struct *work)
+{
+	struct uvc_device *dev = container_of(work, struct uvc_device,
+					      async_ctrl.work);
+	struct uvc_ctrl_work *w = &dev->async_ctrl;
+	int ret;
+
+	__uvc_ctrl_status_event(dev, w);
 
 	/* Resubmit the URB. */
 	w->urb->interval = dev->int_ep->desc.bInterval;
@@ -1321,6 +1328,24 @@ bool uvc_ctrl_status_event(struct urb *urb, struct uvc_video_chain *chain,
 	return true;
 }
 
+void uvc_ctrl_status_event_direct(struct uvc_video_chain *chain,
+				  struct uvc_control *ctrl, const u8 *data)
+{
+	struct uvc_device *dev = chain->dev;
+	struct uvc_ctrl_work w;
+
+	if (list_empty(&ctrl->info.mappings)) {
+		ctrl->handle = NULL;
+		return;
+	}
+
+	w.data = data;
+	w.chain = chain;
+	w.ctrl = ctrl;
+
+	__uvc_ctrl_status_event(dev, &w);
+}
+
 static bool uvc_ctrl_xctrls_has_control(const struct v4l2_ext_control *xctrls,
 					unsigned int xctrls_count, u32 id)
 {
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index c50b0546901f..d7954dcc2b60 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -845,6 +845,8 @@ void uvc_ctrl_cleanup_device(struct uvc_device *dev);
 int uvc_ctrl_restore_values(struct uvc_device *dev);
 bool uvc_ctrl_status_event(struct urb *urb, struct uvc_video_chain *chain,
 			   struct uvc_control *ctrl, const u8 *data);
+void uvc_ctrl_status_event_direct(struct uvc_video_chain *chain,
+				  struct uvc_control *ctrl, const u8 *data);
 
 int uvc_ctrl_begin(struct uvc_video_chain *chain);
 int __uvc_ctrl_commit(struct uvc_fh *handle, int rollback,
-- 
2.29.2.729.g45daf8777d-goog

Re: [PATCH v6 04/11] media: uvcvideo: Add uvc_ctrl_status_event_direct

[Laurent Pinchart]

Hi Ricardo,

Thank you for the patch.

On Wed, Dec 23, 2020 at 12:04:39AM +0100, Ricardo Ribalda wrote:
> Provide a code path for events that can be sent without a work-queue,
> this is, that do not belong to an URB and are not handled in the top
> half on an irq-handled.
> 
> Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
> ---
>  drivers/media/usb/uvc/uvc_ctrl.c | 35 +++++++++++++++++++++++++++-----
>  drivers/media/usb/uvc/uvcvideo.h |  2 ++
>  2 files changed, 32 insertions(+), 5 deletions(-)
> 
> diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
> index 9f6174a10e73..5fe228a3213b 100644
> --- a/drivers/media/usb/uvc/uvc_ctrl.c
> +++ b/drivers/media/usb/uvc/uvc_ctrl.c
> @@ -1254,17 +1254,14 @@ static void uvc_ctrl_send_slave_event(struct uvc_video_chain *chain,
>  	uvc_ctrl_send_event(chain, handle, ctrl, mapping, val, changes);
>  }
>  
> -static void uvc_ctrl_status_event_work(struct work_struct *work)
> +static void __uvc_ctrl_status_event(struct uvc_device *dev,
> +				    struct uvc_ctrl_work *w)

As this function doesn't deal with the work queue, should it receive the
members of uvc_ctrl_work as direct arguments ? You could then drop the
separate uvc_ctrl_status_event_direct(), or rather rename this function
to uvc_ctrl_status_event_direct().

Speaking of names, maybe uvc_ctrl_status_event() should be renamed to
uvc_ctrl_status_event_async(), and this function become
uvc_ctrl_status_event() ?

>  {
> -	struct uvc_device *dev = container_of(work, struct uvc_device,
> -					      async_ctrl.work);
> -	struct uvc_ctrl_work *w = &dev->async_ctrl;
>  	struct uvc_video_chain *chain = w->chain;
>  	struct uvc_control_mapping *mapping;
>  	struct uvc_control *ctrl = w->ctrl;
>  	struct uvc_fh *handle;
>  	unsigned int i;
> -	int ret;
>  
>  	mutex_lock(&chain->ctrl_mutex);
>  
> @@ -1291,6 +1288,16 @@ static void uvc_ctrl_status_event_work(struct work_struct *work)
>  	}
>  
>  	mutex_unlock(&chain->ctrl_mutex);
> +}
> +
> +static void uvc_ctrl_status_event_work(struct work_struct *work)
> +{
> +	struct uvc_device *dev = container_of(work, struct uvc_device,
> +					      async_ctrl.work);
> +	struct uvc_ctrl_work *w = &dev->async_ctrl;
> +	int ret;
> +
> +	__uvc_ctrl_status_event(dev, w);
>  
>  	/* Resubmit the URB. */
>  	w->urb->interval = dev->int_ep->desc.bInterval;
> @@ -1321,6 +1328,24 @@ bool uvc_ctrl_status_event(struct urb *urb, struct uvc_video_chain *chain,
>  	return true;
>  }
>  
> +void uvc_ctrl_status_event_direct(struct uvc_video_chain *chain,
> +				  struct uvc_control *ctrl, const u8 *data)
> +{
> +	struct uvc_device *dev = chain->dev;
> +	struct uvc_ctrl_work w;
> +
> +	if (list_empty(&ctrl->info.mappings)) {
> +		ctrl->handle = NULL;
> +		return;
> +	}
> +
> +	w.data = data;
> +	w.chain = chain;
> +	w.ctrl = ctrl;
> +
> +	__uvc_ctrl_status_event(dev, &w);
> +}
> +
>  static bool uvc_ctrl_xctrls_has_control(const struct v4l2_ext_control *xctrls,
>  					unsigned int xctrls_count, u32 id)
>  {
> diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
> index c50b0546901f..d7954dcc2b60 100644
> --- a/drivers/media/usb/uvc/uvcvideo.h
> +++ b/drivers/media/usb/uvc/uvcvideo.h
> @@ -845,6 +845,8 @@ void uvc_ctrl_cleanup_device(struct uvc_device *dev);
>  int uvc_ctrl_restore_values(struct uvc_device *dev);
>  bool uvc_ctrl_status_event(struct urb *urb, struct uvc_video_chain *chain,
>  			   struct uvc_control *ctrl, const u8 *data);
> +void uvc_ctrl_status_event_direct(struct uvc_video_chain *chain,
> +				  struct uvc_control *ctrl, const u8 *data);
>  
>  int uvc_ctrl_begin(struct uvc_video_chain *chain);
>  int __uvc_ctrl_commit(struct uvc_fh *handle, int rollback,

-- 
Regards,

Laurent Pinchart

[PATCH v6 05/11] media: uvcvideo: Allow entity-defined get_info and get_cur

[Ricardo Ribalda]

Allows controls to get their properties and current value
from an entity-defined function instead of via a query to the USB
device.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c | 22 ++++++++++++++++++----
 drivers/media/usb/uvc/uvcvideo.h |  5 +++++
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index 5fe228a3213b..acdc9b032306 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -980,10 +980,20 @@ static int __uvc_ctrl_get(struct uvc_video_chain *chain,
 		return -EACCES;
 
 	if (!ctrl->loaded) {
-		ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, ctrl->entity->id,
-				chain->dev->intfnum, ctrl->info.selector,
+		if (ctrl->entity->get_cur) {
+			ret = ctrl->entity->get_cur(chain->dev,
+				ctrl->entity,
+				ctrl->info.selector,
 				uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
 				ctrl->info.size);
+		} else {
+			ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,
+				ctrl->entity->id,
+				chain->dev->intfnum,
+				ctrl->info.selector,
+				uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
+				ctrl->info.size);
+		}
 		if (ret < 0)
 			return ret;
 
@@ -1712,8 +1722,12 @@ static int uvc_ctrl_get_flags(struct uvc_device *dev,
 	if (data == NULL)
 		return -ENOMEM;
 
-	ret = uvc_query_ctrl(dev, UVC_GET_INFO, ctrl->entity->id, dev->intfnum,
-			     info->selector, data, 1);
+	if (ctrl->entity->get_info)
+		ret = ctrl->entity->get_info(dev, ctrl->entity,
+					     ctrl->info.selector, data);
+	else
+		ret = uvc_query_ctrl(dev, UVC_GET_INFO, ctrl->entity->id,
+				     dev->intfnum, info->selector, data, 1);
 	if (!ret)
 		info->flags |= (data[0] & UVC_CONTROL_CAP_GET ?
 				UVC_CTRL_FLAG_GET_CUR : 0)
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index d7954dcc2b60..64a3d901db19 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -358,6 +358,11 @@ struct uvc_entity {
 	u8 bNrInPins;
 	u8 *baSourceID;
 
+	int (*get_info)(struct uvc_device *dev, struct uvc_entity *entity,
+			u8 cs, u8 *caps);
+	int (*get_cur)(struct uvc_device *dev, struct uvc_entity *entity,
+		       u8 cs, void *data, u16 size);
+
 	unsigned int ncontrols;
 	struct uvc_control *controls;
 };
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 06/11] media: uvcvideo: Implement UVC_EXT_GPIO_UNIT

[Ricardo Ribalda]

Some devices can implement a physical switch to disable the input of the
camera on demand. Think of it like an elegant privacy sticker.

The system can read the status of the privacy switch via a GPIO.

It is important to know the status of the switch, e.g. to notify the
user when the camera will produce black frames and a videochat
application is used.

In some systems, the GPIO is connected to main SoC instead of the
camera controller, with the connection reported by the system firmware
(ACPI or DT). In that case, the UVC device isn't aware of the GPIO. We
need to implement a virtual entity to handle the GPIO fully on the
driver side.

For example, for ACPI-based systems, the GPIO is reported in the USB
device object:

  Scope (\_SB.PCI0.XHCI.RHUB.HS07)
  {

	  /.../

    Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
    {
        GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
            "\\_SB.PCI0.GPIO", 0x00, ResourceConsumer, ,
            )
            {   // Pin list
                0x0064
            }
    })
    Name (_DSD, Package (0x02)  // _DSD: Device-Specific Data
    {
        ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
        Package (0x01)
        {
            Package (0x02)
            {
                "privacy-gpio",
                Package (0x04)
                {
                    \_SB.PCI0.XHCI.RHUB.HS07,
                    Zero,
                    Zero,
                    One
                }
            }
        }
    })
  }

Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c   |   3 +
 drivers/media/usb/uvc/uvc_driver.c | 133 +++++++++++++++++++++++++++++
 drivers/media/usb/uvc/uvc_entity.c |   1 +
 drivers/media/usb/uvc/uvcvideo.h   |  17 ++++
 4 files changed, 154 insertions(+)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index acdc9b032306..22857b6a71e2 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -2311,6 +2311,9 @@ int uvc_ctrl_init_device(struct uvc_device *dev)
 		} else if (UVC_ENTITY_TYPE(entity) == UVC_ITT_CAMERA) {
 			bmControls = entity->camera.bmControls;
 			bControlSize = entity->camera.bControlSize;
+		} else if (UVC_ENTITY_TYPE(entity) == UVC_EXT_GPIO_UNIT) {
+			bmControls = entity->gpio.bmControls;
+			bControlSize = entity->gpio.bControlSize;
 		}
 
 		/* Remove bogus/blacklisted controls */
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index c0c5f75ade40..5873237bbfa8 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/atomic.h>
+#include <linux/gpio/consumer.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/module.h>
@@ -1020,6 +1021,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 }
 
 static const u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
+static const u8 uvc_gpio_guid[16] = UVC_GUID_EXT_GPIO_CONTROLLER;
 static const u8 uvc_media_transport_input_guid[16] =
 	UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
 static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
@@ -1051,6 +1053,9 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u16 id,
 	 * is initialized by the caller.
 	 */
 	switch (type) {
+	case UVC_EXT_GPIO_UNIT:
+		memcpy(entity->guid, uvc_gpio_guid, 16);
+		break;
 	case UVC_ITT_CAMERA:
 		memcpy(entity->guid, uvc_camera_guid, 16);
 		break;
@@ -1464,6 +1469,115 @@ static int uvc_parse_control(struct uvc_device *dev)
 	return 0;
 }
 
+/* -----------------------------------------------------------------------------
+ * Privacy GPIO
+ */
+
+static u8 uvc_gpio_update_value(struct uvc_device *dev)
+{
+	struct uvc_entity *unit = dev->gpio_unit;
+	struct uvc_video_chain *chain;
+	u8 gpio_val, old_val, new_val;
+
+	gpio_val = new_val = gpiod_get_value_cansleep(unit->gpio.gpio_privacy);
+
+	old_val = atomic_xchg(&unit->gpio.gpio_privacy_value, gpio_val);
+	if (new_val == old_val)
+		return new_val;
+
+	/* GPIO entities are always on the first chain. */
+	chain = list_first_entry(&dev->chains, struct uvc_video_chain, list);
+	uvc_ctrl_status_event_direct(chain, unit->controls, &new_val);
+
+	return new_val;
+}
+
+static int uvc_gpio_get_cur(struct uvc_device *dev, struct uvc_entity *entity,
+			    u8 cs, void *data, u16 size)
+{
+	if (cs != UVC_CT_PRIVACY_CONTROL || size < 1 || !dev->gpio_unit)
+		return -EINVAL;
+
+	*(u8 *)data = uvc_gpio_update_value(dev);
+
+	return 0;
+}
+
+static int uvc_gpio_get_info(struct uvc_device *dev, struct uvc_entity *entity,
+			     u8 cs, u8 *caps)
+{
+	if (cs != UVC_CT_PRIVACY_CONTROL)
+		return -EINVAL;
+
+	*caps = UVC_CONTROL_CAP_GET | UVC_CONTROL_CAP_AUTOUPDATE;
+	return 0;
+}
+
+static irqreturn_t uvc_gpio_irq(int irq, void *data)
+{
+	struct uvc_device *dev = data;
+
+	if (!dev->gpio_unit)
+		return IRQ_HANDLED;
+
+	uvc_gpio_update_value(dev);
+	return IRQ_HANDLED;
+}
+
+static int uvc_gpio_parse(struct uvc_device *dev)
+{
+	struct uvc_entity *unit;
+	struct gpio_desc *gpio_privacy;
+	int irq;
+
+	gpio_privacy = devm_gpiod_get_optional(&dev->udev->dev, "privacy",
+					       GPIOD_IN);
+	if (IS_ERR_OR_NULL(gpio_privacy))
+		return PTR_ERR_OR_ZERO(gpio_privacy);
+
+	unit = uvc_alloc_entity(UVC_EXT_GPIO_UNIT, UVC_EXT_GPIO_UNIT_ID, 0, 1);
+	if (!unit)
+		return -ENOMEM;
+
+	irq = gpiod_to_irq(gpio_privacy);
+	if (irq == -EPROBE_DEFER)
+		return -EPROBE_DEFER;
+
+	if (irq < 0)
+		dev_warn(&dev->udev->dev,
+			 "No IRQ for privacy GPIO (%d)\n", irq);
+
+	atomic_set(&unit->gpio.gpio_privacy_value, -1);
+	unit->gpio.gpio_privacy = gpio_privacy;
+	unit->gpio.irq = irq;
+	unit->gpio.bControlSize = 1;
+	unit->gpio.bmControls = (u8 *)unit + sizeof(*unit);
+	unit->gpio.bmControls[0] = 1;
+	unit->get_cur = uvc_gpio_get_cur;
+	unit->get_info = uvc_gpio_get_info;
+	strncpy(unit->name, "GPIO", sizeof(unit->name) - 1);
+
+	list_add_tail(&unit->list, &dev->entities);
+
+	dev->gpio_unit = unit;
+
+	return 0;
+}
+
+static int uvc_gpio_init_irq(struct uvc_device *dev)
+{
+	struct uvc_entity *unit = dev->gpio_unit;
+
+	if (!unit || unit->gpio.irq < 0)
+		return 0;
+
+	return devm_request_threaded_irq(&dev->udev->dev, unit->gpio.irq, NULL,
+					 uvc_gpio_irq,
+					 IRQF_ONESHOT | IRQF_TRIGGER_FALLING |
+					   IRQF_TRIGGER_RISING,
+					 "uvc_privacy_gpio", dev);
+}
+
 /* ------------------------------------------------------------------------
  * UVC device scan
  */
@@ -1953,6 +2067,13 @@ static int uvc_scan_device(struct uvc_device *dev)
 		return -1;
 	}
 
+	/* Add GPIO entity to the first chain. */
+	if (dev->gpio_unit) {
+		chain = list_first_entry(&dev->chains,
+					 struct uvc_video_chain, list);
+		list_add_tail(&dev->gpio_unit->chain, &chain->entities);
+	}
+
 	return 0;
 }
 
@@ -2285,6 +2406,12 @@ static int uvc_probe(struct usb_interface *intf,
 		goto error;
 	}
 
+	/* Parse the associated GPIOs. */
+	if (uvc_gpio_parse(dev) < 0) {
+		uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
+		goto error;
+	}
+
 	uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
 		dev->uvc_version >> 8, dev->uvc_version & 0xff,
 		udev->product ? udev->product : "<unnamed>",
@@ -2329,6 +2456,12 @@ static int uvc_probe(struct usb_interface *intf,
 			"supported.\n", ret);
 	}
 
+	ret = uvc_gpio_init_irq(dev);
+	if (ret < 0)
+		dev_warn(&dev->udev->dev,
+			 "Unable to request privacy GPIO IRQ %d. Continuing without privacy events\n",
+			 ret);
+
 	uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
 	usb_enable_autosuspend(udev);
 	return 0;
diff --git a/drivers/media/usb/uvc/uvc_entity.c b/drivers/media/usb/uvc/uvc_entity.c
index ca3a9c2eec27..6a9ba5b498db 100644
--- a/drivers/media/usb/uvc/uvc_entity.c
+++ b/drivers/media/usb/uvc/uvc_entity.c
@@ -105,6 +105,7 @@ static int uvc_mc_init_entity(struct uvc_video_chain *chain,
 		case UVC_OTT_DISPLAY:
 		case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
 		case UVC_EXTERNAL_VENDOR_SPECIFIC:
+		case UVC_EXT_GPIO_UNIT:
 		default:
 			function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
 			break;
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 64a3d901db19..132513a66ee5 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -6,6 +6,7 @@
 #error "The uvcvideo.h header is deprecated, use linux/uvcvideo.h instead."
 #endif /* __KERNEL__ */
 
+#include <linux/atomic.h>
 #include <linux/kernel.h>
 #include <linux/poll.h>
 #include <linux/usb.h>
@@ -37,6 +38,8 @@
 	(UVC_ENTITY_IS_TERM(entity) && \
 	((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
 
+#define UVC_EXT_GPIO_UNIT		0x7ffe
+#define UVC_EXT_GPIO_UNIT_ID		0x100
 
 /* ------------------------------------------------------------------------
  * GUIDs
@@ -56,6 +59,9 @@
 #define UVC_GUID_UVC_SELECTOR \
 	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02}
+#define UVC_GUID_EXT_GPIO_CONTROLLER \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03}
 
 #define UVC_GUID_FORMAT_MJPEG \
 	{ 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
@@ -213,6 +219,7 @@
  */
 
 struct uvc_device;
+struct gpio_desc;
 
 /* TODO: Put the most frequently accessed fields at the beginning of
  * structures to maximize cache efficiency.
@@ -353,6 +360,14 @@ struct uvc_entity {
 			u8  *bmControls;
 			u8  *bmControlsType;
 		} extension;
+
+		struct {
+			u8  bControlSize;
+			u8  *bmControls;
+			struct gpio_desc *gpio_privacy;
+			int irq;
+			atomic_t gpio_privacy_value;
+		} gpio;
 	};
 
 	u8 bNrInPins;
@@ -690,6 +705,8 @@ struct uvc_device {
 		struct uvc_control *ctrl;
 		const void *data;
 	} async_ctrl;
+
+	struct uvc_entity *gpio_unit;
 };
 
 enum uvc_handle_state {
-- 
2.29.2.729.g45daf8777d-goog

Re: [PATCH v6 06/11] media: uvcvideo: Implement UVC_EXT_GPIO_UNIT

[Laurent Pinchart]

Hi Ricardo,

Thank you for the patch.

On Wed, Dec 23, 2020 at 12:04:41AM +0100, Ricardo Ribalda wrote:
> Some devices can implement a physical switch to disable the input of the
> camera on demand. Think of it like an elegant privacy sticker.
> 
> The system can read the status of the privacy switch via a GPIO.
> 
> It is important to know the status of the switch, e.g. to notify the
> user when the camera will produce black frames and a videochat
> application is used.
> 
> In some systems, the GPIO is connected to main SoC instead of the

s/to main/to the main/

> camera controller, with the connection reported by the system firmware
> (ACPI or DT). In that case, the UVC device isn't aware of the GPIO. We
> need to implement a virtual entity to handle the GPIO fully on the
> driver side.
> 
> For example, for ACPI-based systems, the GPIO is reported in the USB
> device object:
> 
>   Scope (\_SB.PCI0.XHCI.RHUB.HS07)
>   {
> 
> 	  /.../
> 
>     Name (_CRS, ResourceTemplate ()  // _CRS: Current Resource Settings
>     {
>         GpioIo (Exclusive, PullDefault, 0x0000, 0x0000, IoRestrictionOutputOnly,
>             "\\_SB.PCI0.GPIO", 0x00, ResourceConsumer, ,
>             )
>             {   // Pin list
>                 0x0064
>             }
>     })
>     Name (_DSD, Package (0x02)  // _DSD: Device-Specific Data
>     {
>         ToUUID ("daffd814-6eba-4d8c-8a91-bc9bbf4aa301") /* Device Properties for _DSD */,
>         Package (0x01)
>         {
>             Package (0x02)
>             {
>                 "privacy-gpio",
>                 Package (0x04)
>                 {
>                     \_SB.PCI0.XHCI.RHUB.HS07,
>                     Zero,
>                     Zero,
>                     One
>                 }
>             }
>         }
>     })
>   }
> 
> Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
> ---
>  drivers/media/usb/uvc/uvc_ctrl.c   |   3 +
>  drivers/media/usb/uvc/uvc_driver.c | 133 +++++++++++++++++++++++++++++
>  drivers/media/usb/uvc/uvc_entity.c |   1 +
>  drivers/media/usb/uvc/uvcvideo.h   |  17 ++++
>  4 files changed, 154 insertions(+)
> 
> diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
> index acdc9b032306..22857b6a71e2 100644
> --- a/drivers/media/usb/uvc/uvc_ctrl.c
> +++ b/drivers/media/usb/uvc/uvc_ctrl.c
> @@ -2311,6 +2311,9 @@ int uvc_ctrl_init_device(struct uvc_device *dev)
>  		} else if (UVC_ENTITY_TYPE(entity) == UVC_ITT_CAMERA) {
>  			bmControls = entity->camera.bmControls;
>  			bControlSize = entity->camera.bControlSize;
> +		} else if (UVC_ENTITY_TYPE(entity) == UVC_EXT_GPIO_UNIT) {
> +			bmControls = entity->gpio.bmControls;
> +			bControlSize = entity->gpio.bControlSize;
>  		}
>  
>  		/* Remove bogus/blacklisted controls */
> diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
> index c0c5f75ade40..5873237bbfa8 100644
> --- a/drivers/media/usb/uvc/uvc_driver.c
> +++ b/drivers/media/usb/uvc/uvc_driver.c
> @@ -7,6 +7,7 @@
>   */
>  
>  #include <linux/atomic.h>
> +#include <linux/gpio/consumer.h>
>  #include <linux/kernel.h>
>  #include <linux/list.h>
>  #include <linux/module.h>
> @@ -1020,6 +1021,7 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>  }
>  
>  static const u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
> +static const u8 uvc_gpio_guid[16] = UVC_GUID_EXT_GPIO_CONTROLLER;
>  static const u8 uvc_media_transport_input_guid[16] =
>  	UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
>  static const u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
> @@ -1051,6 +1053,9 @@ static struct uvc_entity *uvc_alloc_entity(u16 type, u16 id,
>  	 * is initialized by the caller.
>  	 */
>  	switch (type) {
> +	case UVC_EXT_GPIO_UNIT:
> +		memcpy(entity->guid, uvc_gpio_guid, 16);
> +		break;
>  	case UVC_ITT_CAMERA:
>  		memcpy(entity->guid, uvc_camera_guid, 16);
>  		break;
> @@ -1464,6 +1469,115 @@ static int uvc_parse_control(struct uvc_device *dev)
>  	return 0;
>  }
>  
> +/* -----------------------------------------------------------------------------
> + * Privacy GPIO
> + */
> +
> +static u8 uvc_gpio_update_value(struct uvc_device *dev)
> +{
> +	struct uvc_entity *unit = dev->gpio_unit;
> +	struct uvc_video_chain *chain;
> +	u8 gpio_val, old_val, new_val;
> +
> +	gpio_val = new_val = gpiod_get_value_cansleep(unit->gpio.gpio_privacy);
> +
> +	old_val = atomic_xchg(&unit->gpio.gpio_privacy_value, gpio_val);
> +	if (new_val == old_val)
> +		return new_val;
> +
> +	/* GPIO entities are always on the first chain. */
> +	chain = list_first_entry(&dev->chains, struct uvc_video_chain, list);
> +	uvc_ctrl_status_event_direct(chain, unit->controls, &new_val);
> +
> +	return new_val;
> +}
> +
> +static int uvc_gpio_get_cur(struct uvc_device *dev, struct uvc_entity *entity,
> +			    u8 cs, void *data, u16 size)
> +{
> +	if (cs != UVC_CT_PRIVACY_CONTROL || size < 1 || !dev->gpio_unit)
> +		return -EINVAL;
> +
> +	*(u8 *)data = uvc_gpio_update_value(dev);
> +
> +	return 0;
> +}
> +
> +static int uvc_gpio_get_info(struct uvc_device *dev, struct uvc_entity *entity,
> +			     u8 cs, u8 *caps)
> +{
> +	if (cs != UVC_CT_PRIVACY_CONTROL)
> +		return -EINVAL;
> +
> +	*caps = UVC_CONTROL_CAP_GET | UVC_CONTROL_CAP_AUTOUPDATE;
> +	return 0;
> +}
> +
> +static irqreturn_t uvc_gpio_irq(int irq, void *data)
> +{
> +	struct uvc_device *dev = data;
> +
> +	if (!dev->gpio_unit)
> +		return IRQ_HANDLED;
> +
> +	uvc_gpio_update_value(dev);
> +	return IRQ_HANDLED;
> +}
> +
> +static int uvc_gpio_parse(struct uvc_device *dev)
> +{
> +	struct uvc_entity *unit;
> +	struct gpio_desc *gpio_privacy;
> +	int irq;
> +
> +	gpio_privacy = devm_gpiod_get_optional(&dev->udev->dev, "privacy",
> +					       GPIOD_IN);
> +	if (IS_ERR_OR_NULL(gpio_privacy))
> +		return PTR_ERR_OR_ZERO(gpio_privacy);
> +
> +	unit = uvc_alloc_entity(UVC_EXT_GPIO_UNIT, UVC_EXT_GPIO_UNIT_ID, 0, 1);
> +	if (!unit)
> +		return -ENOMEM;
> +
> +	irq = gpiod_to_irq(gpio_privacy);
> +	if (irq == -EPROBE_DEFER)
> +		return -EPROBE_DEFER;
> +
> +	if (irq < 0)
> +		dev_warn(&dev->udev->dev,
> +			 "No IRQ for privacy GPIO (%d)\n", irq);
> +
> +	atomic_set(&unit->gpio.gpio_privacy_value, -1);
> +	unit->gpio.gpio_privacy = gpio_privacy;
> +	unit->gpio.irq = irq;
> +	unit->gpio.bControlSize = 1;
> +	unit->gpio.bmControls = (u8 *)unit + sizeof(*unit);
> +	unit->gpio.bmControls[0] = 1;
> +	unit->get_cur = uvc_gpio_get_cur;
> +	unit->get_info = uvc_gpio_get_info;
> +	strncpy(unit->name, "GPIO", sizeof(unit->name) - 1);
> +
> +	list_add_tail(&unit->list, &dev->entities);
> +
> +	dev->gpio_unit = unit;
> +
> +	return 0;
> +}
> +
> +static int uvc_gpio_init_irq(struct uvc_device *dev)
> +{
> +	struct uvc_entity *unit = dev->gpio_unit;
> +
> +	if (!unit || unit->gpio.irq < 0)
> +		return 0;
> +
> +	return devm_request_threaded_irq(&dev->udev->dev, unit->gpio.irq, NULL,
> +					 uvc_gpio_irq,
> +					 IRQF_ONESHOT | IRQF_TRIGGER_FALLING |
> +					   IRQF_TRIGGER_RISING,

Is there any good tool that could check indentation in a git hook ? ;-)

> +					 "uvc_privacy_gpio", dev);
> +}
> +
>  /* ------------------------------------------------------------------------
>   * UVC device scan
>   */
> @@ -1953,6 +2067,13 @@ static int uvc_scan_device(struct uvc_device *dev)
>  		return -1;
>  	}
>  
> +	/* Add GPIO entity to the first chain. */
> +	if (dev->gpio_unit) {
> +		chain = list_first_entry(&dev->chains,
> +					 struct uvc_video_chain, list);
> +		list_add_tail(&dev->gpio_unit->chain, &chain->entities);
> +	}
> +
>  	return 0;
>  }
>  
> @@ -2285,6 +2406,12 @@ static int uvc_probe(struct usb_interface *intf,
>  		goto error;
>  	}
>  
> +	/* Parse the associated GPIOs. */
> +	if (uvc_gpio_parse(dev) < 0) {
> +		uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
> +		goto error;
> +	}
> +
>  	uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
>  		dev->uvc_version >> 8, dev->uvc_version & 0xff,
>  		udev->product ? udev->product : "<unnamed>",
> @@ -2329,6 +2456,12 @@ static int uvc_probe(struct usb_interface *intf,
>  			"supported.\n", ret);
>  	}
>  
> +	ret = uvc_gpio_init_irq(dev);
> +	if (ret < 0)
> +		dev_warn(&dev->udev->dev,
> +			 "Unable to request privacy GPIO IRQ %d. Continuing without privacy events\n",
> +			 ret);
> +
>  	uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
>  	usb_enable_autosuspend(udev);
>  	return 0;
> diff --git a/drivers/media/usb/uvc/uvc_entity.c b/drivers/media/usb/uvc/uvc_entity.c
> index ca3a9c2eec27..6a9ba5b498db 100644
> --- a/drivers/media/usb/uvc/uvc_entity.c
> +++ b/drivers/media/usb/uvc/uvc_entity.c
> @@ -105,6 +105,7 @@ static int uvc_mc_init_entity(struct uvc_video_chain *chain,
>  		case UVC_OTT_DISPLAY:
>  		case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
>  		case UVC_EXTERNAL_VENDOR_SPECIFIC:
> +		case UVC_EXT_GPIO_UNIT:
>  		default:
>  			function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
>  			break;
> diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
> index 64a3d901db19..132513a66ee5 100644
> --- a/drivers/media/usb/uvc/uvcvideo.h
> +++ b/drivers/media/usb/uvc/uvcvideo.h
> @@ -6,6 +6,7 @@
>  #error "The uvcvideo.h header is deprecated, use linux/uvcvideo.h instead."
>  #endif /* __KERNEL__ */
>  
> +#include <linux/atomic.h>
>  #include <linux/kernel.h>
>  #include <linux/poll.h>
>  #include <linux/usb.h>
> @@ -37,6 +38,8 @@
>  	(UVC_ENTITY_IS_TERM(entity) && \
>  	((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
>  
> +#define UVC_EXT_GPIO_UNIT		0x7ffe
> +#define UVC_EXT_GPIO_UNIT_ID		0x100
>  
>  /* ------------------------------------------------------------------------
>   * GUIDs
> @@ -56,6 +59,9 @@
>  #define UVC_GUID_UVC_SELECTOR \
>  	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
>  	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02}
> +#define UVC_GUID_EXT_GPIO_CONTROLLER \
> +	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
> +	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03}
>  
>  #define UVC_GUID_FORMAT_MJPEG \
>  	{ 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
> @@ -213,6 +219,7 @@
>   */
>  
>  struct uvc_device;
> +struct gpio_desc;

Alphabetical order ? :-)

Otherwise this looks good, pending an agreement on how to handle the
case where the GPIO can't generate an IRQ.

>  
>  /* TODO: Put the most frequently accessed fields at the beginning of
>   * structures to maximize cache efficiency.
> @@ -353,6 +360,14 @@ struct uvc_entity {
>  			u8  *bmControls;
>  			u8  *bmControlsType;
>  		} extension;
> +
> +		struct {
> +			u8  bControlSize;
> +			u8  *bmControls;
> +			struct gpio_desc *gpio_privacy;
> +			int irq;
> +			atomic_t gpio_privacy_value;
> +		} gpio;
>  	};
>  
>  	u8 bNrInPins;
> @@ -690,6 +705,8 @@ struct uvc_device {
>  		struct uvc_control *ctrl;
>  		const void *data;
>  	} async_ctrl;
> +
> +	struct uvc_entity *gpio_unit;
>  };
>  
>  enum uvc_handle_state {

-- 
Regards,

Laurent Pinchart

[PATCH v6 07/11] media: uvcvideo: Add Privacy control based on EXT_GPIO

[Ricardo Ribalda]

Add a new control and mapping for Privacy controls connected to
UVC_GUID_EXT_GPIO_CONTROLLERs.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index 22857b6a71e2..8519f4fbbeb1 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -347,6 +347,14 @@ static const struct uvc_control_info uvc_ctrls[] = {
 				| UVC_CTRL_FLAG_RESTORE
 				| UVC_CTRL_FLAG_AUTO_UPDATE,
 	},
+	{
+		.entity		= UVC_GUID_EXT_GPIO_CONTROLLER,
+		.selector	= UVC_CT_PRIVACY_CONTROL,
+		.index		= 0,
+		.size		= 1,
+		.flags		= UVC_CTRL_FLAG_GET_CUR
+				| UVC_CTRL_FLAG_AUTO_UPDATE,
+	},
 };
 
 static const struct uvc_menu_info power_line_frequency_controls[] = {
@@ -735,6 +743,16 @@ static const struct uvc_control_mapping uvc_ctrl_mappings[] = {
 		.v4l2_type	= V4L2_CTRL_TYPE_BOOLEAN,
 		.data_type	= UVC_CTRL_DATA_TYPE_BOOLEAN,
 	},
+	{
+		.id		= V4L2_CID_PRIVACY,
+		.name		= "Privacy",
+		.entity		= UVC_GUID_EXT_GPIO_CONTROLLER,
+		.selector	= UVC_CT_PRIVACY_CONTROL,
+		.size		= 1,
+		.offset		= 0,
+		.v4l2_type	= V4L2_CTRL_TYPE_BOOLEAN,
+		.data_type	= UVC_CTRL_DATA_TYPE_BOOLEAN,
+	},
 };
 
 /* ------------------------------------------------------------------------
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 08/11] media: uvcvideo: Implement UVC_QUIRK_PRIVACY_DURING_STREAM

[Ricardo Ribalda]

Some devices can only read the privacy_pin if the device is
streaming.

This patch implement a quirk for such devices, in order to avoid invalid
reads and/or spurious events.

Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_driver.c | 37 ++++++++++++++++++++++++++++--
 drivers/media/usb/uvc/uvc_video.c  | 27 ++++++++++++++++++++++
 drivers/media/usb/uvc/uvcvideo.h   |  5 ++++
 3 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 5873237bbfa8..15f7ec7d7e9b 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/atomic.h>
+#include <linux/dmi.h>
 #include <linux/gpio/consumer.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
@@ -1473,7 +1474,7 @@ static int uvc_parse_control(struct uvc_device *dev)
  * Privacy GPIO
  */
 
-static u8 uvc_gpio_update_value(struct uvc_device *dev)
+u8 uvc_gpio_update_value(struct uvc_device *dev)
 {
 	struct uvc_entity *unit = dev->gpio_unit;
 	struct uvc_video_chain *chain;
@@ -1498,6 +1499,9 @@ static int uvc_gpio_get_cur(struct uvc_device *dev, struct uvc_entity *entity,
 	if (cs != UVC_CT_PRIVACY_CONTROL || size < 1 || !dev->gpio_unit)
 		return -EINVAL;
 
+	if (!dev->gpio_unit->gpio.is_gpio_ready)
+		return -EBUSY;
+
 	*(u8 *)data = uvc_gpio_update_value(dev);
 
 	return 0;
@@ -1517,13 +1521,31 @@ static irqreturn_t uvc_gpio_irq(int irq, void *data)
 {
 	struct uvc_device *dev = data;
 
-	if (!dev->gpio_unit)
+	if (!dev->gpio_unit || !dev->gpio_unit->gpio.is_gpio_ready)
 		return IRQ_HANDLED;
 
 	uvc_gpio_update_value(dev);
 	return IRQ_HANDLED;
 }
 
+static const struct dmi_system_id privacy_valid_during_streamon[] = {
+	{
+		.ident = "HP Elite c1030 Chromebook",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Jinlon"),
+		},
+	},
+	{
+		.ident = "HP Pro c640 Chromebook",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "HP"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Dratini"),
+		},
+	},
+	{ } /* terminate list */
+};
+
 static int uvc_gpio_parse(struct uvc_device *dev)
 {
 	struct uvc_entity *unit;
@@ -1557,6 +1579,17 @@ static int uvc_gpio_parse(struct uvc_device *dev)
 	unit->get_info = uvc_gpio_get_info;
 	strncpy(unit->name, "GPIO", sizeof(unit->name) - 1);
 
+	/*
+	 * Note: This quirk will not match external UVC cameras,
+	 * as they will not have the corresponding ACPI GPIO entity.
+	 */
+	if (dmi_check_system(privacy_valid_during_streamon)) {
+		dev->quirks |= UVC_QUIRK_PRIVACY_DURING_STREAM;
+		unit->gpio.is_gpio_ready = false;
+	} else {
+		unit->gpio.is_gpio_ready = true;
+	}
+
 	list_add_tail(&unit->list, &dev->entities);
 
 	dev->gpio_unit = unit;
diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
index a6a441d92b94..03d6ed7fc8ed 100644
--- a/drivers/media/usb/uvc/uvc_video.c
+++ b/drivers/media/usb/uvc/uvc_video.c
@@ -2077,6 +2077,29 @@ int uvc_video_init(struct uvc_streaming *stream)
 	return 0;
 }
 
+static void uvc_gpio_privacy_quirks(struct uvc_streaming *stream, bool enable)
+{
+	struct uvc_device *dev = stream->dev;
+	struct uvc_video_chain *first_chain;
+
+	if (!(dev->quirks & UVC_QUIRK_PRIVACY_DURING_STREAM))
+		return;
+
+	if (!dev->gpio_unit)
+		return;
+
+	first_chain = list_first_entry(&dev->chains,
+				       struct uvc_video_chain, list);
+	/* GPIO entities are always on the first chain. */
+	if (stream->chain != first_chain)
+		return;
+
+	dev->gpio_unit->gpio.is_gpio_ready = enable;
+
+	if (enable)
+		uvc_gpio_update_value(stream->dev);
+}
+
 int uvc_video_start_streaming(struct uvc_streaming *stream)
 {
 	int ret;
@@ -2094,6 +2117,8 @@ int uvc_video_start_streaming(struct uvc_streaming *stream)
 	if (ret < 0)
 		goto error_video;
 
+	uvc_gpio_privacy_quirks(stream, true);
+
 	return 0;
 
 error_video:
@@ -2106,6 +2131,8 @@ int uvc_video_start_streaming(struct uvc_streaming *stream)
 
 void uvc_video_stop_streaming(struct uvc_streaming *stream)
 {
+	uvc_gpio_privacy_quirks(stream, false);
+
 	uvc_video_stop_transfer(stream, 1);
 
 	if (stream->intf->num_altsetting > 1) {
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 132513a66ee5..58422c99f05f 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -209,6 +209,7 @@
 #define UVC_QUIRK_RESTORE_CTRLS_ON_INIT	0x00000400
 #define UVC_QUIRK_FORCE_Y8		0x00000800
 #define UVC_QUIRK_FORCE_BPP		0x00001000
+#define UVC_QUIRK_PRIVACY_DURING_STREAM	0x00002000
 
 /* Format flags */
 #define UVC_FMT_FLAG_COMPRESSED		0x00000001
@@ -367,6 +368,7 @@ struct uvc_entity {
 			struct gpio_desc *gpio_privacy;
 			int irq;
 			atomic_t gpio_privacy_value;
+			bool is_gpio_ready;
 		} gpio;
 	};
 
@@ -822,6 +824,9 @@ extern const struct v4l2_file_operations uvc_fops;
 int uvc_mc_register_entities(struct uvc_video_chain *chain);
 void uvc_mc_cleanup_entity(struct uvc_entity *entity);
 
+/* Privacy gpio */
+u8 uvc_gpio_update_value(struct uvc_device *dev);
+
 /* Video */
 int uvc_video_init(struct uvc_streaming *stream);
 int uvc_video_suspend(struct uvc_streaming *stream);
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 09/11] media: uvcvideo: Use dev_ printk aliases

[Ricardo Ribalda]

Replace all the uses of printk() and uvc_printk() with its
equivalent dev_ alias macros.

Modify uvc_warn_once() macro to use dev_info instead printk().

They are more standard across the kernel tree and provide
more context about the error.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Suggested-by: Joe Perches <joe@perches.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c   | 12 +++----
 drivers/media/usb/uvc/uvc_driver.c | 50 ++++++++++++++++--------------
 drivers/media/usb/uvc/uvc_entity.c | 10 +++---
 drivers/media/usb/uvc/uvc_status.c | 13 ++++----
 drivers/media/usb/uvc/uvc_video.c  | 48 ++++++++++++++--------------
 drivers/media/usb/uvc/uvcvideo.h   | 25 +++++++--------
 6 files changed, 81 insertions(+), 77 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index 8519f4fbbeb1..f837ffdc8c43 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -1331,8 +1331,8 @@ static void uvc_ctrl_status_event_work(struct work_struct *work)
 	w->urb->interval = dev->int_ep->desc.bInterval;
 	ret = usb_submit_urb(w->urb, GFP_KERNEL);
 	if (ret < 0)
-		uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
-			   ret);
+		dev_err(&dev->udev->dev,
+			"Failed to resubmit status URB (%d).\n", ret);
 }
 
 bool uvc_ctrl_status_event(struct urb *urb, struct uvc_video_chain *chain,
@@ -2030,10 +2030,10 @@ int uvc_ctrl_restore_values(struct uvc_device *dev)
 			if (!ctrl->initialized || !ctrl->modified ||
 			    (ctrl->info.flags & UVC_CTRL_FLAG_RESTORE) == 0)
 				continue;
-
-			printk(KERN_INFO "restoring control %pUl/%u/%u\n",
-				ctrl->info.entity, ctrl->info.index,
-				ctrl->info.selector);
+			dev_info(&dev->udev->dev,
+				 "restoring control %pUl/%u/%u\n",
+				 ctrl->info.entity, ctrl->info.index,
+				 ctrl->info.selector);
 			ctrl->dirty = 1;
 		}
 
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 15f7ec7d7e9b..e348d8bb625d 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -536,8 +536,8 @@ static int uvc_parse_format(struct uvc_device *dev,
 				sizeof(format->name));
 			format->fcc = fmtdesc->fcc;
 		} else {
-			uvc_printk(KERN_INFO, "Unknown video format %pUl\n",
-				&buffer[5]);
+			dev_info(&streaming->intf->dev,
+				 "Unknown video format %pUl\n", &buffer[5]);
 			snprintf(format->name, sizeof(format->name), "%pUl\n",
 				&buffer[5]);
 			format->fcc = 0;
@@ -2096,7 +2096,7 @@ static int uvc_scan_device(struct uvc_device *dev)
 		uvc_scan_fallback(dev);
 
 	if (list_empty(&dev->chains)) {
-		uvc_printk(KERN_INFO, "No valid video chain found.\n");
+		dev_info(&dev->udev->dev, "No valid video chain found.\n");
 		return -1;
 	}
 
@@ -2255,8 +2255,9 @@ int uvc_register_video_device(struct uvc_device *dev,
 
 	ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
 	if (ret < 0) {
-		uvc_printk(KERN_ERR, "Failed to register %s device (%d).\n",
-			   v4l2_type_names[type], ret);
+		dev_err(&stream->intf->dev,
+			"Failed to register %s device (%d).\n",
+			v4l2_type_names[type], ret);
 		return ret;
 	}
 
@@ -2272,8 +2273,8 @@ static int uvc_register_video(struct uvc_device *dev,
 	/* Initialize the streaming interface with default parameters. */
 	ret = uvc_video_init(stream);
 	if (ret < 0) {
-		uvc_printk(KERN_ERR, "Failed to initialize the device (%d).\n",
-			   ret);
+		dev_err(&stream->intf->dev,
+			"Failed to initialize the device (%d).\n", ret);
 		return ret;
 	}
 
@@ -2307,8 +2308,9 @@ static int uvc_register_terms(struct uvc_device *dev,
 
 		stream = uvc_stream_by_id(dev, term->id);
 		if (stream == NULL) {
-			uvc_printk(KERN_INFO, "No streaming interface found "
-				   "for terminal %u.", term->id);
+			dev_info(&dev->udev->dev,
+				 "No streaming interface found for terminal %u.",
+				 term->id);
 			continue;
 		}
 
@@ -2341,8 +2343,8 @@ static int uvc_register_chains(struct uvc_device *dev)
 #ifdef CONFIG_MEDIA_CONTROLLER
 		ret = uvc_mc_register_entities(chain);
 		if (ret < 0)
-			uvc_printk(KERN_INFO,
-				   "Failed to register entities (%d).\n", ret);
+			dev_info(&dev->udev->dev,
+				 "Failed to register entities (%d).\n", ret);
 #endif
 	}
 
@@ -2445,17 +2447,18 @@ static int uvc_probe(struct usb_interface *intf,
 		goto error;
 	}
 
-	uvc_printk(KERN_INFO, "Found UVC %u.%02x device %s (%04x:%04x)\n",
-		dev->uvc_version >> 8, dev->uvc_version & 0xff,
-		udev->product ? udev->product : "<unnamed>",
-		le16_to_cpu(udev->descriptor.idVendor),
-		le16_to_cpu(udev->descriptor.idProduct));
+	dev_info(&dev->udev->dev, "Found UVC %u.%02x device %s (%04x:%04x)\n",
+		 dev->uvc_version >> 8, dev->uvc_version & 0xff,
+		 udev->product ? udev->product : "<unnamed>",
+		 le16_to_cpu(udev->descriptor.idVendor),
+		 le16_to_cpu(udev->descriptor.idProduct));
 
 	if (dev->quirks != dev->info->quirks) {
-		uvc_printk(KERN_INFO, "Forcing device quirks to 0x%x by module "
-			"parameter for testing purpose.\n", dev->quirks);
-		uvc_printk(KERN_INFO, "Please report required quirks to the "
-			"linux-uvc-devel mailing list.\n");
+		dev_info(&dev->udev->dev,
+			 "Forcing device quirks to 0x%x by module parameter for testing purpose.\n",
+			 dev->quirks);
+		dev_info(&dev->udev->dev,
+			 "Please report required quirks to the linux-uvc-devel mailing list.\n");
 	}
 
 	/* Register the V4L2 device. */
@@ -2484,9 +2487,9 @@ static int uvc_probe(struct usb_interface *intf,
 
 	/* Initialize the interrupt URB. */
 	if ((ret = uvc_status_init(dev)) < 0) {
-		uvc_printk(KERN_INFO, "Unable to initialize the status "
-			"endpoint (%d), status interrupt will not be "
-			"supported.\n", ret);
+		dev_info(&dev->udev->dev,
+			 "Unable to initialize the status endpoint (%d), status interrupt will not be supported.\n",
+			 ret);
 	}
 
 	ret = uvc_gpio_init_irq(dev);
@@ -3192,7 +3195,6 @@ static int __init uvc_init(void)
 		return ret;
 	}
 
-	printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
 	return 0;
 }
 
diff --git a/drivers/media/usb/uvc/uvc_entity.c b/drivers/media/usb/uvc/uvc_entity.c
index 6a9ba5b498db..7c4d2f93d351 100644
--- a/drivers/media/usb/uvc/uvc_entity.c
+++ b/drivers/media/usb/uvc/uvc_entity.c
@@ -140,8 +140,9 @@ int uvc_mc_register_entities(struct uvc_video_chain *chain)
 	list_for_each_entry(entity, &chain->entities, chain) {
 		ret = uvc_mc_init_entity(chain, entity);
 		if (ret < 0) {
-			uvc_printk(KERN_INFO, "Failed to initialize entity for "
-				   "entity %u\n", entity->id);
+			dev_info(&chain->dev->udev->dev,
+				 "Failed to initialize entity for entity %u\n",
+				 entity->id);
 			return ret;
 		}
 	}
@@ -149,8 +150,9 @@ int uvc_mc_register_entities(struct uvc_video_chain *chain)
 	list_for_each_entry(entity, &chain->entities, chain) {
 		ret = uvc_mc_create_links(chain, entity);
 		if (ret < 0) {
-			uvc_printk(KERN_INFO, "Failed to create links for "
-				   "entity %u\n", entity->id);
+			dev_info(&chain->dev->udev->dev,
+				 "Failed to create links for entity %u\n",
+				 entity->id);
 			return ret;
 		}
 	}
diff --git a/drivers/media/usb/uvc/uvc_status.c b/drivers/media/usb/uvc/uvc_status.c
index 2bdb0ff203f8..36fa196a9258 100644
--- a/drivers/media/usb/uvc/uvc_status.c
+++ b/drivers/media/usb/uvc/uvc_status.c
@@ -208,8 +208,9 @@ static void uvc_status_complete(struct urb *urb)
 		return;
 
 	default:
-		uvc_printk(KERN_WARNING, "Non-zero status (%d) in status "
-			"completion handler.\n", urb->status);
+		dev_warn(&dev->udev->dev,
+			 "Non-zero status (%d) in status completion handler.\n",
+			 urb->status);
 		return;
 	}
 
@@ -243,10 +244,10 @@ static void uvc_status_complete(struct urb *urb)
 
 	/* Resubmit the URB. */
 	urb->interval = dev->int_ep->desc.bInterval;
-	if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
-		uvc_printk(KERN_ERR, "Failed to resubmit status URB (%d).\n",
-			ret);
-	}
+	ret = usb_submit_urb(urb, GFP_ATOMIC);
+	if (ret < 0)
+		dev_err(&dev->udev->dev,
+			"Failed to resubmit status URB (%d).\n", ret);
 }
 
 int uvc_status_init(struct uvc_device *dev)
diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
index 03d6ed7fc8ed..07baead470fc 100644
--- a/drivers/media/usb/uvc/uvc_video.c
+++ b/drivers/media/usb/uvc/uvc_video.c
@@ -76,9 +76,9 @@ int uvc_query_ctrl(struct uvc_device *dev, u8 query, u8 unit,
 	if (likely(ret == size))
 		return 0;
 
-	uvc_printk(KERN_ERR,
-		   "Failed to query (%s) UVC control %u on unit %u: %d (exp. %u).\n",
-		   uvc_query_name(query), cs, unit, ret, size);
+	dev_err(&dev->udev->dev,
+		"Failed to query (%s) UVC control %u on unit %u: %d (exp. %u).\n",
+		uvc_query_name(query), cs, unit, ret, size);
 
 	if (ret != -EPIPE)
 		return ret;
@@ -254,9 +254,9 @@ static int uvc_get_video_ctrl(struct uvc_streaming *stream,
 		ret = -EIO;
 		goto out;
 	} else if (ret != size) {
-		uvc_printk(KERN_ERR, "Failed to query (%u) UVC %s control : "
-			"%d (exp. %u).\n", query, probe ? "probe" : "commit",
-			ret, size);
+		dev_err(&stream->intf->dev,
+			"Failed to query (%u) UVC %s control : %d (exp. %u).\n",
+			query, probe ? "probe" : "commit", ret, size);
 		ret = -EIO;
 		goto out;
 	}
@@ -334,9 +334,9 @@ static int uvc_set_video_ctrl(struct uvc_streaming *stream,
 		probe ? UVC_VS_PROBE_CONTROL : UVC_VS_COMMIT_CONTROL, data,
 		size, uvc_timeout_param);
 	if (ret != size) {
-		uvc_printk(KERN_ERR, "Failed to set UVC %s control : "
-			"%d (exp. %u).\n", probe ? "probe" : "commit",
-			ret, size);
+		dev_err(&stream->intf->dev,
+			"Failed to set UVC %s control : %d (exp. %u).\n",
+			probe ? "probe" : "commit", ret, size);
 		ret = -EIO;
 	}
 
@@ -1120,8 +1120,8 @@ static void uvc_video_copy_data_work(struct work_struct *work)
 
 	ret = usb_submit_urb(uvc_urb->urb, GFP_KERNEL);
 	if (ret < 0)
-		uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
-			   ret);
+		dev_err(&uvc_urb->stream->intf->dev,
+			"Failed to resubmit video URB (%d).\n", ret);
 }
 
 static void uvc_video_decode_data(struct uvc_urb *uvc_urb,
@@ -1507,8 +1507,9 @@ static void uvc_video_complete(struct urb *urb)
 		break;
 
 	default:
-		uvc_printk(KERN_WARNING, "Non-zero status (%d) in video "
-			"completion handler.\n", urb->status);
+		dev_warn(&stream->intf->dev,
+			 "Non-zero status (%d) in video completion handler.\n",
+			 urb->status);
 		fallthrough;
 	case -ENOENT:		/* usb_poison_urb() called. */
 		if (stream->frozen)
@@ -1545,9 +1546,8 @@ static void uvc_video_complete(struct urb *urb)
 	if (!uvc_urb->async_operations) {
 		ret = usb_submit_urb(uvc_urb->urb, GFP_ATOMIC);
 		if (ret < 0)
-			uvc_printk(KERN_ERR,
-				   "Failed to resubmit video URB (%d).\n",
-				   ret);
+			dev_err(&stream->intf->dev,
+				"Failed to resubmit video URB (%d).\n", ret);
 		return;
 	}
 
@@ -1893,8 +1893,9 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
 	for_each_uvc_urb(uvc_urb, stream) {
 		ret = usb_submit_urb(uvc_urb->urb, gfp_flags);
 		if (ret < 0) {
-			uvc_printk(KERN_ERR, "Failed to submit URB %u (%d).\n",
-				   uvc_urb_index(uvc_urb), ret);
+			dev_err(&stream->intf->dev,
+				"Failed to submit URB %u (%d).\n",
+				uvc_urb_index(uvc_urb), ret);
 			uvc_video_stop_transfer(stream, 1);
 			return ret;
 		}
@@ -1989,7 +1990,8 @@ int uvc_video_init(struct uvc_streaming *stream)
 	int ret;
 
 	if (stream->nformats == 0) {
-		uvc_printk(KERN_INFO, "No supported video formats found.\n");
+		dev_info(&stream->intf->dev,
+			 "No supported video formats found.\n");
 		return -EINVAL;
 	}
 
@@ -2029,8 +2031,8 @@ int uvc_video_init(struct uvc_streaming *stream)
 	}
 
 	if (format->nframes == 0) {
-		uvc_printk(KERN_INFO, "No frame descriptor found for the "
-			"default format.\n");
+		dev_info(&stream->intf->dev,
+			 "No frame descriptor found for the default format.\n");
 		return -EINVAL;
 	}
 
@@ -2064,8 +2066,8 @@ int uvc_video_init(struct uvc_streaming *stream)
 		if (stream->intf->num_altsetting == 1)
 			stream->decode = uvc_video_encode_bulk;
 		else {
-			uvc_printk(KERN_INFO, "Isochronous endpoints are not "
-				"supported for video output devices.\n");
+			dev_info(&stream->intf->dev,
+				 "Isochronous endpoints are not supported for video output devices.\n");
 			return -EINVAL;
 		}
 	}
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 58422c99f05f..3dcb9e417b3d 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -754,20 +754,17 @@ extern unsigned int uvc_trace_param;
 extern unsigned int uvc_timeout_param;
 extern unsigned int uvc_hw_timestamps_param;
 
-#define uvc_trace(flag, msg...) \
-	do { \
-		if (uvc_trace_param & flag) \
-			printk(KERN_DEBUG "uvcvideo: " msg); \
-	} while (0)
-
-#define uvc_warn_once(dev, warn, msg...) \
-	do { \
-		if (!test_and_set_bit(warn, &dev->warnings)) \
-			printk(KERN_INFO "uvcvideo: " msg); \
-	} while (0)
-
-#define uvc_printk(level, msg...) \
-	printk(level "uvcvideo: " msg)
+#define uvc_trace(flag, fmt, ...)					\
+do {									\
+	if (uvc_trace_param & flag)					\
+		printk(KERN_DEBUG "uvcvideo: " fmt, ##__VA_ARGS__);	\
+} while (0)
+
+#define uvc_warn_once(_dev, warn, fmt, ...)				\
+do {									\
+	if (!test_and_set_bit(warn, &(_dev)->warnings))			\
+		dev_info(&(_dev)->udev->dev, fmt, ##__VA_ARGS__);	\
+} while (0)
 
 /* --------------------------------------------------------------------------
  * Internal functions.
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 10/11] media: uvcvideo: New macro uvc_trace_cont

[Ricardo Ribalda]

Remove all the duplicated code around printk(KERN_CONT, with a new macro.

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Suggested-by: Joe Perches <joe@perches.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_driver.c | 57 +++++++++++-------------------
 drivers/media/usb/uvc/uvcvideo.h   |  6 ++++
 2 files changed, 27 insertions(+), 36 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index e348d8bb625d..c146944db091 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -1646,8 +1646,7 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 {
 	switch (UVC_ENTITY_TYPE(entity)) {
 	case UVC_VC_EXTENSION_UNIT:
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " <- XU %d", entity->id);
+		uvc_trace_cont(UVC_TRACE_PROBE, " <- XU %d", entity->id);
 
 		if (entity->bNrInPins != 1) {
 			uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has more "
@@ -1658,8 +1657,7 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		break;
 
 	case UVC_VC_PROCESSING_UNIT:
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " <- PU %d", entity->id);
+		uvc_trace_cont(UVC_TRACE_PROBE, " <- PU %d", entity->id);
 
 		if (chain->processing != NULL) {
 			uvc_trace(UVC_TRACE_DESCR, "Found multiple "
@@ -1671,8 +1669,7 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		break;
 
 	case UVC_VC_SELECTOR_UNIT:
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " <- SU %d", entity->id);
+		uvc_trace_cont(UVC_TRACE_PROBE, " <- SU %d", entity->id);
 
 		/* Single-input selector units are ignored. */
 		if (entity->bNrInPins == 1)
@@ -1690,27 +1687,22 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 	case UVC_ITT_VENDOR_SPECIFIC:
 	case UVC_ITT_CAMERA:
 	case UVC_ITT_MEDIA_TRANSPORT_INPUT:
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " <- IT %d\n", entity->id);
+		uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
 
 		break;
 
 	case UVC_OTT_VENDOR_SPECIFIC:
 	case UVC_OTT_DISPLAY:
 	case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " OT %d", entity->id);
+		uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
 
 		break;
 
 	case UVC_TT_STREAMING:
-		if (UVC_ENTITY_IS_ITERM(entity)) {
-			if (uvc_trace_param & UVC_TRACE_PROBE)
-				printk(KERN_CONT " <- IT %d\n", entity->id);
-		} else {
-			if (uvc_trace_param & UVC_TRACE_PROBE)
-				printk(KERN_CONT " OT %d", entity->id);
-		}
+		if (UVC_ENTITY_IS_ITERM(entity))
+			uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
+		else
+			uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
 
 		break;
 
@@ -1757,13 +1749,11 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 			}
 
 			list_add_tail(&forward->chain, &chain->entities);
-			if (uvc_trace_param & UVC_TRACE_PROBE) {
-				if (!found)
-					printk(KERN_CONT " (->");
+			if (!found)
+				uvc_trace_cont(UVC_TRACE_PROBE, " (->");
 
-				printk(KERN_CONT " XU %d", forward->id);
-				found = 1;
-			}
+			uvc_trace_cont(UVC_TRACE_PROBE, " XU %d", forward->id);
+			found = 1;
 			break;
 
 		case UVC_OTT_VENDOR_SPECIFIC:
@@ -1777,18 +1767,16 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 			}
 
 			list_add_tail(&forward->chain, &chain->entities);
-			if (uvc_trace_param & UVC_TRACE_PROBE) {
-				if (!found)
-					printk(KERN_CONT " (->");
+			if (!found)
+				uvc_trace_cont(UVC_TRACE_PROBE, " (->");
 
-				printk(KERN_CONT " OT %d", forward->id);
-				found = 1;
-			}
+			uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", forward->id);
+			found = 1;
 			break;
 		}
 	}
 	if (found)
-		printk(KERN_CONT ")");
+		uvc_trace_cont(UVC_TRACE_PROBE, ")");
 
 	return 0;
 }
@@ -1813,8 +1801,7 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 			break;
 		}
 
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT " <- IT");
+		uvc_trace_cont(UVC_TRACE_PROBE, " <- IT");
 
 		chain->selector = entity;
 		for (i = 0; i < entity->bNrInPins; ++i) {
@@ -1834,15 +1821,13 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 				return -EINVAL;
 			}
 
-			if (uvc_trace_param & UVC_TRACE_PROBE)
-				printk(KERN_CONT " %d", term->id);
+			uvc_trace_cont(UVC_TRACE_PROBE, " %d", term->id);
 
 			list_add_tail(&term->chain, &chain->entities);
 			uvc_scan_chain_forward(chain, term, entity);
 		}
 
-		if (uvc_trace_param & UVC_TRACE_PROBE)
-			printk(KERN_CONT "\n");
+		uvc_trace_cont(UVC_TRACE_PROBE, "\n");
 
 		id = 0;
 		break;
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 3dcb9e417b3d..a362ba6d5295 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -760,6 +760,12 @@ do {									\
 		printk(KERN_DEBUG "uvcvideo: " fmt, ##__VA_ARGS__);	\
 } while (0)
 
+#define uvc_trace_cont(flag, fmt, ...)					\
+do {									\
+	if (uvc_trace_param & flag)					\
+		pr_cont(fmt, ##__VA_ARGS__);				\
+} while (0)
+
 #define uvc_warn_once(_dev, warn, fmt, ...)				\
 do {									\
 	if (!test_and_set_bit(warn, &(_dev)->warnings))			\
-- 
2.29.2.729.g45daf8777d-goog

[PATCH v6 11/11] media: uvcvideo: use dev_printk() for uvc_trace()

[Ricardo Ribalda]

Instead of calling prink() inside uvc_trace, use dev_printk(), which adds
context to the output.

Now that we are at it, regroup the strings so the messages can be easily
"grepable".

Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Suggested-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/media/usb/uvc/uvc_ctrl.c   |  66 ++++---
 drivers/media/usb/uvc/uvc_driver.c | 298 +++++++++++++++--------------
 drivers/media/usb/uvc/uvc_isight.c |  16 +-
 drivers/media/usb/uvc/uvc_queue.c  |   9 +-
 drivers/media/usb/uvc/uvc_status.c |  19 +-
 drivers/media/usb/uvc/uvc_v4l2.c   |  53 +++--
 drivers/media/usb/uvc/uvc_video.c  |  72 +++----
 drivers/media/usb/uvc/uvcvideo.h   |  11 +-
 8 files changed, 291 insertions(+), 253 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index f837ffdc8c43..bf448c213c53 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -906,8 +906,8 @@ static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
 	}
 
 	if (ctrl == NULL && !next)
-		uvc_trace(UVC_TRACE_CONTROL, "Control 0x%08x not found.\n",
-				v4l2_id);
+		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
+			  "Control 0x%08x not found.\n", v4l2_id);
 
 	return ctrl;
 }
@@ -1820,9 +1820,9 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 	ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id, dev->intfnum,
 			     info->selector, data, 2);
 	if (ret < 0) {
-		uvc_trace(UVC_TRACE_CONTROL,
+		uvc_trace(dev, UVC_TRACE_CONTROL,
 			  "GET_LEN failed on control %pUl/%u (%d).\n",
-			   info->entity, info->selector, ret);
+			  info->entity, info->selector, ret);
 		goto done;
 	}
 
@@ -1833,7 +1833,7 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 
 	ret = uvc_ctrl_get_flags(dev, ctrl, info);
 	if (ret < 0) {
-		uvc_trace(UVC_TRACE_CONTROL,
+		uvc_trace(dev, UVC_TRACE_CONTROL,
 			  "Failed to get flags for control %pUl/%u (%d).\n",
 			  info->entity, info->selector, ret);
 		goto done;
@@ -1841,8 +1841,8 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 
 	uvc_ctrl_fixup_xu_info(dev, ctrl, info);
 
-	uvc_trace(UVC_TRACE_CONTROL, "XU control %pUl/%u queried: len %u, "
-		  "flags { get %u set %u auto %u }.\n",
+	uvc_trace(dev, UVC_TRACE_CONTROL,
+		  "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }.\n",
 		  info->entity, info->selector, info->size,
 		  (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
 		  (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
@@ -1871,9 +1871,10 @@ static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
 
 	ret = uvc_ctrl_add_info(dev, ctrl, &info);
 	if (ret < 0)
-		uvc_trace(UVC_TRACE_CONTROL, "Failed to initialize control "
-			  "%pUl/%u on device %s entity %u\n", info.entity,
-			  info.selector, dev->udev->devpath, ctrl->entity->id);
+		uvc_trace(dev, UVC_TRACE_CONTROL,
+			  "Failed to initialize control %pUl/%u on device %s entity %u\n",
+			  info.entity, info.selector, dev->udev->devpath,
+			  ctrl->entity->id);
 
 	return ret;
 }
@@ -1901,8 +1902,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
 	}
 
 	if (!found) {
-		uvc_trace(UVC_TRACE_CONTROL, "Extension unit %u not found.\n",
-			xqry->unit);
+		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
+			  "Extension unit %u not found.\n", xqry->unit);
 		return -ENOENT;
 	}
 
@@ -1917,8 +1918,9 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
 	}
 
 	if (!found) {
-		uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u not found.\n",
-			entity->guid, xqry->selector);
+		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
+			  "Control %pUl/%u not found.\n", entity->guid,
+			  xqry->selector);
 		return -ENOENT;
 	}
 
@@ -2066,9 +2068,10 @@ static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
 
 	ctrl->initialized = 1;
 
-	uvc_trace(UVC_TRACE_CONTROL, "Added control %pUl/%u to device %s "
-		"entity %u\n", ctrl->info.entity, ctrl->info.selector,
-		dev->udev->devpath, ctrl->entity->id);
+	uvc_trace(dev, UVC_TRACE_CONTROL,
+		  "Added control %pUl/%u to device %s entity %u\n",
+		  ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
+		  ctrl->entity->id);
 
 	return 0;
 }
@@ -2105,9 +2108,9 @@ static int __uvc_ctrl_add_mapping(struct uvc_device *dev,
 		map->set = uvc_set_le_value;
 
 	list_add_tail(&map->list, &ctrl->info.mappings);
-	uvc_trace(UVC_TRACE_CONTROL,
-		"Adding mapping '%s' to control %pUl/%u.\n",
-		map->name, ctrl->info.entity, ctrl->info.selector);
+	uvc_trace(dev, UVC_TRACE_CONTROL,
+		  "Adding mapping '%s' to control %pUl/%u.\n",
+		  map->name, ctrl->info.entity, ctrl->info.selector);
 
 	return 0;
 }
@@ -2123,9 +2126,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 	int ret;
 
 	if (mapping->id & ~V4L2_CTRL_ID_MASK) {
-		uvc_trace(UVC_TRACE_CONTROL, "Can't add mapping '%s', control "
-			"id 0x%08x is invalid.\n", mapping->name,
-			mapping->id);
+		uvc_trace(dev, UVC_TRACE_CONTROL,
+			  "Can't add mapping '%s', control id 0x%08x is invalid.\n",
+			  mapping->name, mapping->id);
 		return -EINVAL;
 	}
 
@@ -2170,9 +2173,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 
 	list_for_each_entry(map, &ctrl->info.mappings, list) {
 		if (mapping->id == map->id) {
-			uvc_trace(UVC_TRACE_CONTROL, "Can't add mapping '%s', "
-				"control id 0x%08x already exists.\n",
-				mapping->name, mapping->id);
+			uvc_trace(dev, UVC_TRACE_CONTROL,
+				  "Can't add mapping '%s', control id 0x%08x already exists.\n",
+				  mapping->name, mapping->id);
 			ret = -EEXIST;
 			goto done;
 		}
@@ -2181,9 +2184,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 	/* Prevent excess memory consumption */
 	if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
 		atomic_dec(&dev->nmappings);
-		uvc_trace(UVC_TRACE_CONTROL, "Can't add mapping '%s', maximum "
-			"mappings count (%u) exceeded.\n", mapping->name,
-			UVC_MAX_CONTROL_MAPPINGS);
+		uvc_trace(dev, UVC_TRACE_CONTROL,
+			  "Can't add mapping '%s', maximum mappings count (%u) exceeded.\n",
+			  mapping->name, UVC_MAX_CONTROL_MAPPINGS);
 		ret = -ENOMEM;
 		goto done;
 	}
@@ -2252,8 +2255,9 @@ static void uvc_ctrl_prune_entity(struct uvc_device *dev,
 		    !uvc_test_bit(controls, blacklist[i].index))
 			continue;
 
-		uvc_trace(UVC_TRACE_CONTROL, "%u/%u control is black listed, "
-			"removing it.\n", entity->id, blacklist[i].index);
+		uvc_trace(dev, UVC_TRACE_CONTROL,
+			  "%u/%u control is black listed, removing it.\n",
+			  entity->id, blacklist[i].index);
 
 		uvc_clear_bit(controls, blacklist[i].index);
 	}
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index c146944db091..1f72bda6036e 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -521,10 +521,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 	case UVC_VS_FORMAT_FRAME_BASED:
 		n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
 		if (buflen < n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d FORMAT error\n",
-			       dev->udev->devnum,
-			       alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d FORMAT error\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -585,10 +585,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 
 	case UVC_VS_FORMAT_MJPEG:
 		if (buflen < 11) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d FORMAT error\n",
-			       dev->udev->devnum,
-			       alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d FORMAT error\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -601,10 +601,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 
 	case UVC_VS_FORMAT_DV:
 		if (buflen < 9) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d FORMAT error\n",
-			       dev->udev->devnum,
-			       alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d FORMAT error\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -619,9 +619,9 @@ static int uvc_parse_format(struct uvc_device *dev,
 			strscpy(format->name, "HD-DV", sizeof(format->name));
 			break;
 		default:
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d: unknown DV format %u\n",
-			       dev->udev->devnum,
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d: unknown DV format %u\n",
+				  dev->udev->devnum,
 			       alts->desc.bInterfaceNumber, buffer[8]);
 			return -EINVAL;
 		}
@@ -648,14 +648,14 @@ static int uvc_parse_format(struct uvc_device *dev,
 	case UVC_VS_FORMAT_STREAM_BASED:
 		/* Not supported yet. */
 	default:
-		uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-		       "interface %d unsupported format %u\n",
-		       dev->udev->devnum, alts->desc.bInterfaceNumber,
-		       buffer[2]);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d videostreaming interface %d unsupported format %u\n",
+			  dev->udev->devnum, alts->desc.bInterfaceNumber,
+			  buffer[2]);
 		return -EINVAL;
 	}
 
-	uvc_trace(UVC_TRACE_DESCR, "Found format %s.\n", format->name);
+	uvc_trace(dev, UVC_TRACE_DESCR, "Found format %s.\n", format->name);
 
 	buflen -= buffer[0];
 	buffer += buffer[0];
@@ -674,9 +674,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 		n = n ? n : 3;
 
 		if (buflen < 26 + 4*n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d FRAME error\n", dev->udev->devnum,
-			       alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d FRAME error\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -738,10 +739,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 				frame->dwDefaultFrameInterval;
 		}
 
-		uvc_trace(UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
-			frame->wWidth, frame->wHeight,
-			10000000/frame->dwDefaultFrameInterval,
-			(100000000/frame->dwDefaultFrameInterval)%10);
+		uvc_trace(dev, UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
+			  frame->wWidth, frame->wHeight,
+			  10000000 / frame->dwDefaultFrameInterval,
+			  (100000000 / frame->dwDefaultFrameInterval) % 10);
 
 		format->nframes++;
 		buflen -= buffer[0];
@@ -757,10 +758,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 	if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
 	    buffer[2] == UVC_VS_COLORFORMAT) {
 		if (buflen < 6) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			       "interface %d COLORFORMAT error\n",
-			       dev->udev->devnum,
-			       alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d COLORFORMAT error\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -792,16 +793,18 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 	if (intf->cur_altsetting->desc.bInterfaceSubClass
 		!= UVC_SC_VIDEOSTREAMING) {
-		uvc_trace(UVC_TRACE_DESCR, "device %d interface %d isn't a "
-			"video streaming interface\n", dev->udev->devnum,
-			intf->altsetting[0].desc.bInterfaceNumber);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d interface %d isn't a video streaming interface\n",
+			  dev->udev->devnum,
+			  intf->altsetting[0].desc.bInterfaceNumber);
 		return -EINVAL;
 	}
 
 	if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
-		uvc_trace(UVC_TRACE_DESCR, "device %d interface %d is already "
-			"claimed\n", dev->udev->devnum,
-			intf->altsetting[0].desc.bInterfaceNumber);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d interface %d is already claimed\n",
+			  dev->udev->devnum,
+			  intf->altsetting[0].desc.bInterfaceNumber);
 		return -EINVAL;
 	}
 
@@ -823,8 +826,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 			if (ep->extralen > 2 &&
 			    ep->extra[1] == USB_DT_CS_INTERFACE) {
-				uvc_trace(UVC_TRACE_DESCR, "trying extra data "
-					"from endpoint %u.\n", i);
+				uvc_trace(dev, UVC_TRACE_DESCR,
+					  "trying extra data from endpoint %u.\n",
+					  i);
 				buffer = alts->endpoint[i].extra;
 				buflen = alts->endpoint[i].extralen;
 				break;
@@ -839,8 +843,8 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (buflen <= 2) {
-		uvc_trace(UVC_TRACE_DESCR, "no class-specific streaming "
-			"interface descriptors found.\n");
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "no class-specific streaming interface descriptors found.\n");
 		goto error;
 	}
 
@@ -857,9 +861,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 		break;
 
 	default:
-		uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
-			"%d HEADER descriptor not found.\n", dev->udev->devnum,
-			alts->desc.bInterfaceNumber);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d videostreaming interface %d HEADER descriptor not found.\n",
+			  dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -867,9 +871,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	n = buflen >= size ? buffer[size-1] : 0;
 
 	if (buflen < size + p*n) {
-		uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-			"interface %d HEADER descriptor is invalid.\n",
-			dev->udev->devnum, alts->desc.bInterfaceNumber);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d videostreaming interface %d HEADER descriptor is invalid.\n",
+			  dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -919,10 +923,10 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 		case UVC_VS_FORMAT_MPEG2TS:
 		case UVC_VS_FORMAT_STREAM_BASED:
-			uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming "
-				"interface %d FORMAT %u is not supported.\n",
-				dev->udev->devnum,
-				alts->desc.bInterfaceNumber, _buffer[2]);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videostreaming interface %d FORMAT %u is not supported.\n",
+				  dev->udev->devnum,
+				  alts->desc.bInterfaceNumber, _buffer[2]);
 			break;
 
 		case UVC_VS_FRAME_UNCOMPRESSED:
@@ -944,9 +948,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (nformats == 0) {
-		uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
-			"%d has no supported formats defined.\n",
-			dev->udev->devnum, alts->desc.bInterfaceNumber);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d videostreaming interface %d has no supported formats defined.\n",
+			  dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -993,9 +997,10 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (buflen)
-		uvc_trace(UVC_TRACE_DESCR, "device %d videostreaming interface "
-			"%d has %u bytes of trailing descriptor garbage.\n",
-			dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage.\n",
+			  dev->udev->devnum, alts->desc.bInterfaceNumber,
+			  buflen);
 
 	/* Parse the alternate settings to find the maximum bandwidth. */
 	for (i = 0; i < intf->num_altsetting; ++i) {
@@ -1128,9 +1133,9 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
 		n = buflen >= 25 + p ? buffer[22+p] : 0;
 
 		if (buflen < 25 + p + 2*n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d EXTENSION_UNIT error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d EXTENSION_UNIT error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			break;
 		}
 
@@ -1177,9 +1182,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		n = buflen >= 12 ? buffer[11] : 0;
 
 		if (buflen < 12 + n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d HEADER error\n", udev->devnum,
-				alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d HEADER error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1190,9 +1195,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		for (i = 0; i < n; ++i) {
 			intf = usb_ifnum_to_if(udev, buffer[12+i]);
 			if (intf == NULL) {
-				uvc_trace(UVC_TRACE_DESCR, "device %d "
-					"interface %d doesn't exists\n",
-					udev->devnum, i);
+				uvc_trace(dev, UVC_TRACE_DESCR,
+					  "device %d interface %d doesn't exists\n",
+					  udev->devnum, i);
 				continue;
 			}
 
@@ -1202,9 +1207,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 
 	case UVC_VC_INPUT_TERMINAL:
 		if (buflen < 8) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d INPUT_TERMINAL error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d INPUT_TERMINAL error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1221,11 +1226,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		 */
 		type = get_unaligned_le16(&buffer[4]);
 		if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d INPUT_TERMINAL %d has invalid "
-				"type 0x%04x, skipping\n", udev->devnum,
-				alts->desc.bInterfaceNumber,
-				buffer[3], type);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
+				  udev->devnum, alts->desc.bInterfaceNumber,
+				  buffer[3], type);
 			return 0;
 		}
 
@@ -1244,9 +1248,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		}
 
 		if (buflen < len + n + p) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d INPUT_TERMINAL error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d INPUT_TERMINAL error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1291,9 +1295,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 
 	case UVC_VC_OUTPUT_TERMINAL:
 		if (buflen < 9) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d OUTPUT_TERMINAL error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1302,10 +1306,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		 */
 		type = get_unaligned_le16(&buffer[4]);
 		if ((type & 0xff00) == 0) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d OUTPUT_TERMINAL %d has invalid "
-				"type 0x%04x, skipping\n", udev->devnum,
-				alts->desc.bInterfaceNumber, buffer[3], type);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
+				  udev->devnum, alts->desc.bInterfaceNumber,
+				  buffer[3], type);
 			return 0;
 		}
 
@@ -1329,9 +1333,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		p = buflen >= 5 ? buffer[4] : 0;
 
 		if (buflen < 5 || buflen < 6 + p) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d SELECTOR_UNIT error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d SELECTOR_UNIT error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1355,9 +1359,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		p = dev->uvc_version >= 0x0110 ? 10 : 9;
 
 		if (buflen < p + n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d PROCESSING_UNIT error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d PROCESSING_UNIT error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1388,9 +1392,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		n = buflen >= 24 + p ? buffer[22+p] : 0;
 
 		if (buflen < 24 + p + n) {
-			uvc_trace(UVC_TRACE_DESCR, "device %d videocontrol "
-				"interface %d EXTENSION_UNIT error\n",
-				udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "device %d videocontrol interface %d EXTENSION_UNIT error\n",
+				  udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1415,8 +1419,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		break;
 
 	default:
-		uvc_trace(UVC_TRACE_DESCR, "Found an unknown CS_INTERFACE "
-			"descriptor (%u)\n", buffer[2]);
+		uvc_trace(dev, UVC_TRACE_DESCR,
+			  "Found an unknown CS_INTERFACE descriptor (%u)\n",
+			  buffer[2]);
 		break;
 	}
 
@@ -1461,8 +1466,9 @@ static int uvc_parse_control(struct uvc_device *dev)
 		if (usb_endpoint_is_int_in(desc) &&
 		    le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
 		    desc->bInterval != 0) {
-			uvc_trace(UVC_TRACE_DESCR, "Found a Status endpoint "
-				"(addr %02x).\n", desc->bEndpointAddress);
+			uvc_trace(dev, UVC_TRACE_DESCR,
+				  "Found a Status endpoint (addr %02x).\n",
+				  desc->bEndpointAddress);
 			dev->int_ep = ep;
 		}
 	}
@@ -1649,8 +1655,9 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		uvc_trace_cont(UVC_TRACE_PROBE, " <- XU %d", entity->id);
 
 		if (entity->bNrInPins != 1) {
-			uvc_trace(UVC_TRACE_DESCR, "Extension unit %d has more "
-				"than 1 input pin.\n", entity->id);
+			uvc_trace(chain->dev, UVC_TRACE_DESCR,
+				  "Extension unit %d has more than 1 input pin.\n",
+				  entity->id);
 			return -1;
 		}
 
@@ -1660,8 +1667,8 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		uvc_trace_cont(UVC_TRACE_PROBE, " <- PU %d", entity->id);
 
 		if (chain->processing != NULL) {
-			uvc_trace(UVC_TRACE_DESCR, "Found multiple "
-				"Processing Units in chain.\n");
+			uvc_trace(chain->dev, UVC_TRACE_DESCR,
+				  "Found multiple Processing Units in chain.\n");
 			return -1;
 		}
 
@@ -1676,8 +1683,8 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 			break;
 
 		if (chain->selector != NULL) {
-			uvc_trace(UVC_TRACE_DESCR, "Found multiple Selector "
-				"Units in chain.\n");
+			uvc_trace(chain->dev, UVC_TRACE_DESCR,
+				  "Found multiple Selector Units in chain.\n");
 			return -1;
 		}
 
@@ -1707,8 +1714,9 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		break;
 
 	default:
-		uvc_trace(UVC_TRACE_DESCR, "Unsupported entity type "
-			"0x%04x found in chain.\n", UVC_ENTITY_TYPE(entity));
+		uvc_trace(chain->dev, UVC_TRACE_DESCR,
+			  "Unsupported entity type 0x%04x found in chain.\n",
+			  UVC_ENTITY_TYPE(entity));
 		return -1;
 	}
 
@@ -1734,16 +1742,17 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 		if (forward == prev)
 			continue;
 		if (forward->chain.next || forward->chain.prev) {
-			uvc_trace(UVC_TRACE_DESCR, "Found reference to "
-				"entity %d already in chain.\n", forward->id);
+			uvc_trace(chain->dev, UVC_TRACE_DESCR,
+				  "Found reference to entity %d already in chain.\n",
+				  forward->id);
 			return -EINVAL;
 		}
 
 		switch (UVC_ENTITY_TYPE(forward)) {
 		case UVC_VC_EXTENSION_UNIT:
 			if (forward->bNrInPins != 1) {
-				uvc_trace(UVC_TRACE_DESCR, "Extension unit %d "
-					  "has more than 1 input pin.\n",
+				uvc_trace(chain->dev, UVC_TRACE_DESCR,
+					  "Extension unit %d has more than 1 input pin.\n",
 					  entity->id);
 				return -EINVAL;
 			}
@@ -1761,8 +1770,9 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 		case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
 		case UVC_TT_STREAMING:
 			if (UVC_ENTITY_IS_ITERM(forward)) {
-				uvc_trace(UVC_TRACE_DESCR, "Unsupported input "
-					"terminal %u.\n", forward->id);
+				uvc_trace(chain->dev, UVC_TRACE_DESCR,
+					  "Unsupported input terminal %u.\n",
+					  forward->id);
 				return -EINVAL;
 			}
 
@@ -1808,16 +1818,16 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 			id = entity->baSourceID[i];
 			term = uvc_entity_by_id(chain->dev, id);
 			if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
-				uvc_trace(UVC_TRACE_DESCR, "Selector unit %d "
-					"input %d isn't connected to an "
-					"input terminal\n", entity->id, i);
+				uvc_trace(chain->dev, UVC_TRACE_DESCR,
+					  "Selector unit %d input %d isn't connected to an input terminal\n",
+					  entity->id, i);
 				return -1;
 			}
 
 			if (term->chain.next || term->chain.prev) {
-				uvc_trace(UVC_TRACE_DESCR, "Found reference to "
-					"entity %d already in chain.\n",
-					term->id);
+				uvc_trace(chain->dev, UVC_TRACE_DESCR,
+					  "Found reference to entity %d already in chain.\n",
+					  term->id);
 				return -EINVAL;
 			}
 
@@ -1850,8 +1860,8 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 
 	entity = uvc_entity_by_id(chain->dev, id);
 	if (entity == NULL) {
-		uvc_trace(UVC_TRACE_DESCR, "Found reference to "
-			"unknown entity %d.\n", id);
+		uvc_trace(chain->dev, UVC_TRACE_DESCR,
+			  "Found reference to unknown entity %d.\n", id);
 		return -EINVAL;
 	}
 
@@ -1864,7 +1874,7 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
 {
 	struct uvc_entity *entity, *prev;
 
-	uvc_trace(UVC_TRACE_PROBE, "Scanning UVC chain:");
+	uvc_trace(chain->dev, UVC_TRACE_PROBE, "Scanning UVC chain:");
 
 	entity = term;
 	prev = NULL;
@@ -1872,8 +1882,9 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
 	while (entity != NULL) {
 		/* Entity must not be part of an existing chain */
 		if (entity->chain.next || entity->chain.prev) {
-			uvc_trace(UVC_TRACE_DESCR, "Found reference to "
-				"entity %d already in chain.\n", entity->id);
+			uvc_trace(chain->dev, UVC_TRACE_DESCR,
+				  "Found reference to entity %d already in chain.\n",
+				  entity->id);
 			return -EINVAL;
 		}
 
@@ -2027,7 +2038,7 @@ static int uvc_scan_fallback(struct uvc_device *dev)
 
 	list_add_tail(&chain->list, &dev->chains);
 
-	uvc_trace(UVC_TRACE_PROBE,
+	uvc_trace(dev, UVC_TRACE_PROBE,
 		  "Found a video chain by fallback heuristic (%s).\n",
 		  uvc_print_chain(chain));
 
@@ -2071,7 +2082,8 @@ static int uvc_scan_device(struct uvc_device *dev)
 			continue;
 		}
 
-		uvc_trace(UVC_TRACE_PROBE, "Found a valid video chain (%s).\n",
+		uvc_trace(dev, UVC_TRACE_PROBE,
+			  "Found a valid video chain (%s).\n",
 			  uvc_print_chain(chain));
 
 		list_add_tail(&chain->list, &dev->chains);
@@ -2352,14 +2364,6 @@ static int uvc_probe(struct usb_interface *intf,
 	int function;
 	int ret;
 
-	if (id->idVendor && id->idProduct)
-		uvc_trace(UVC_TRACE_PROBE, "Probing known UVC device %s "
-				"(%04x:%04x)\n", udev->devpath, id->idVendor,
-				id->idProduct);
-	else
-		uvc_trace(UVC_TRACE_PROBE, "Probing generic UVC device %s\n",
-				udev->devpath);
-
 	/* Allocate memory for the device and initialize it. */
 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 	if (dev == NULL)
@@ -2379,6 +2383,14 @@ static int uvc_probe(struct usb_interface *intf,
 	dev->quirks = uvc_quirks_param == -1
 		    ? dev->info->quirks : uvc_quirks_param;
 
+	if (id->idVendor && id->idProduct)
+		uvc_trace(dev, UVC_TRACE_PROBE,
+			  "Probing known UVC device %s (%04x:%04x)\n",
+			  udev->devpath, id->idVendor, id->idProduct);
+	else
+		uvc_trace(dev, UVC_TRACE_PROBE,
+			  "Probing generic UVC device %s\n", udev->devpath);
+
 	if (udev->product != NULL)
 		strscpy(dev->name, udev->product, sizeof(dev->name));
 	else
@@ -2421,14 +2433,14 @@ static int uvc_probe(struct usb_interface *intf,
 
 	/* Parse the Video Class control descriptor. */
 	if (uvc_parse_control(dev) < 0) {
-		uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC "
-			"descriptors.\n");
+		uvc_trace(dev, UVC_TRACE_PROBE,
+			  "Unable to parse UVC descriptors.\n");
 		goto error;
 	}
 
 	/* Parse the associated GPIOs. */
 	if (uvc_gpio_parse(dev) < 0) {
-		uvc_trace(UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
+		uvc_trace(dev, UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
 		goto error;
 	}
 
@@ -2483,7 +2495,7 @@ static int uvc_probe(struct usb_interface *intf,
 			 "Unable to request privacy GPIO IRQ %d. Continuing without privacy events\n",
 			 ret);
 
-	uvc_trace(UVC_TRACE_PROBE, "UVC device initialized.\n");
+	uvc_trace(dev, UVC_TRACE_PROBE, "UVC device initialized.\n");
 	usb_enable_autosuspend(udev);
 	return 0;
 
@@ -2515,7 +2527,7 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 	struct uvc_device *dev = usb_get_intfdata(intf);
 	struct uvc_streaming *stream;
 
-	uvc_trace(UVC_TRACE_SUSPEND, "Suspending interface %u\n",
+	uvc_trace(dev, UVC_TRACE_SUSPEND, "Suspending interface %u\n",
 		intf->cur_altsetting->desc.bInterfaceNumber);
 
 	/* Controls are cached on the fly so they don't need to be saved. */
@@ -2533,8 +2545,8 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 			return uvc_video_suspend(stream);
 	}
 
-	uvc_trace(UVC_TRACE_SUSPEND, "Suspend: video streaming USB interface "
-			"mismatch.\n");
+	uvc_trace(dev, UVC_TRACE_SUSPEND,
+		  "Suspend: video streaming USB interface mismatch.\n");
 	return -EINVAL;
 }
 
@@ -2544,8 +2556,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 	struct uvc_streaming *stream;
 	int ret = 0;
 
-	uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
-		intf->cur_altsetting->desc.bInterfaceNumber);
+	uvc_trace(dev, UVC_TRACE_SUSPEND, "Resuming interface %u\n",
+		  intf->cur_altsetting->desc.bInterfaceNumber);
 
 	if (intf->cur_altsetting->desc.bInterfaceSubClass ==
 	    UVC_SC_VIDEOCONTROL) {
@@ -2573,8 +2585,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 		}
 	}
 
-	uvc_trace(UVC_TRACE_SUSPEND, "Resume: video streaming USB interface "
-			"mismatch.\n");
+	uvc_trace(dev, UVC_TRACE_SUSPEND,
+		  "Resume: video streaming USB interface mismatch.\n");
 	return -EINVAL;
 }
 
diff --git a/drivers/media/usb/uvc/uvc_isight.c b/drivers/media/usb/uvc/uvc_isight.c
index 135fd7fe6852..445c4d39aeff 100644
--- a/drivers/media/usb/uvc/uvc_isight.c
+++ b/drivers/media/usb/uvc/uvc_isight.c
@@ -40,6 +40,7 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
 		0xde, 0xad, 0xfa, 0xce
 	};
 
+	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
 	unsigned int maxlen, nbytes;
 	u8 *mem;
 	int is_header = 0;
@@ -49,15 +50,16 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
 
 	if ((len >= 14 && memcmp(&data[2], hdr, 12) == 0) ||
 	    (len >= 15 && memcmp(&data[3], hdr, 12) == 0)) {
-		uvc_trace(UVC_TRACE_FRAME, "iSight header found\n");
+		uvc_trace(stream->dev, UVC_TRACE_FRAME,
+			  "iSight header found\n");
 		is_header = 1;
 	}
 
 	/* Synchronize to the input stream by waiting for a header packet. */
 	if (buf->state != UVC_BUF_STATE_ACTIVE) {
 		if (!is_header) {
-			uvc_trace(UVC_TRACE_FRAME, "Dropping packet (out of "
-				  "sync).\n");
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "Dropping packet (out of sync).\n");
 			return 0;
 		}
 
@@ -85,8 +87,8 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
 		buf->bytesused += nbytes;
 
 		if (len > maxlen || buf->bytesused == buf->length) {
-			uvc_trace(UVC_TRACE_FRAME, "Frame complete "
-				  "(overflow).\n");
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "Frame complete (overflow).\n");
 			buf->state = UVC_BUF_STATE_DONE;
 		}
 	}
@@ -103,8 +105,8 @@ void uvc_video_decode_isight(struct uvc_urb *uvc_urb, struct uvc_buffer *buf,
 
 	for (i = 0; i < urb->number_of_packets; ++i) {
 		if (urb->iso_frame_desc[i].status < 0) {
-			uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
-				  "lost (%d).\n",
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "USB isochronous frame lost (%d).\n",
 				  urb->iso_frame_desc[i].status);
 		}
 
diff --git a/drivers/media/usb/uvc/uvc_queue.c b/drivers/media/usb/uvc/uvc_queue.c
index cd60c6c1749e..2255daa3e240 100644
--- a/drivers/media/usb/uvc/uvc_queue.c
+++ b/drivers/media/usb/uvc/uvc_queue.c
@@ -32,12 +32,6 @@
  * the driver.
  */
 
-static inline struct uvc_streaming *
-uvc_queue_to_stream(struct uvc_video_queue *queue)
-{
-	return container_of(queue, struct uvc_streaming, queue);
-}
-
 static inline struct uvc_buffer *uvc_vbuf_to_buffer(struct vb2_v4l2_buffer *buf)
 {
 	return container_of(buf, struct uvc_buffer, buf);
@@ -109,7 +103,8 @@ static int uvc_buffer_prepare(struct vb2_buffer *vb)
 
 	if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 	    vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
-		uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
+		uvc_trace(uvc_queue_to_stream(queue)->dev, UVC_TRACE_CAPTURE,
+			  "[E] Bytes used out of bounds.\n");
 		return -EINVAL;
 	}
 
diff --git a/drivers/media/usb/uvc/uvc_status.c b/drivers/media/usb/uvc/uvc_status.c
index 36fa196a9258..b5f493216fcd 100644
--- a/drivers/media/usb/uvc/uvc_status.c
+++ b/drivers/media/usb/uvc/uvc_status.c
@@ -93,20 +93,20 @@ static void uvc_event_streaming(struct uvc_device *dev,
 				struct uvc_streaming_status *status, int len)
 {
 	if (len < 3) {
-		uvc_trace(UVC_TRACE_STATUS, "Invalid streaming status event "
-				"received.\n");
+		uvc_trace(dev, UVC_TRACE_STATUS,
+			  "Invalid streaming status event received.\n");
 		return;
 	}
 
 	if (status->bEvent == 0) {
 		if (len < 4)
 			return;
-		uvc_trace(UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
+		uvc_trace(dev, UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
 			  status->bOriginator,
 			  status->bValue[0] ? "pressed" : "released", len);
 		uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]);
 	} else {
-		uvc_trace(UVC_TRACE_STATUS,
+		uvc_trace(dev, UVC_TRACE_STATUS,
 			  "Stream %u error event %02x len %d.\n",
 			  status->bOriginator, status->bEvent, len);
 	}
@@ -163,12 +163,12 @@ static bool uvc_event_control(struct urb *urb,
 
 	if (len < 6 || status->bEvent != 0 ||
 	    status->bAttribute >= ARRAY_SIZE(attrs)) {
-		uvc_trace(UVC_TRACE_STATUS, "Invalid control status event "
-				"received.\n");
+		uvc_trace(dev, UVC_TRACE_STATUS,
+			  "Invalid control status event received.\n");
 		return false;
 	}
 
-	uvc_trace(UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
+	uvc_trace(dev, UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
 		  status->bOriginator, status->bSelector,
 		  attrs[status->bAttribute], len);
 
@@ -236,8 +236,9 @@ static void uvc_status_complete(struct urb *urb)
 		}
 
 		default:
-			uvc_trace(UVC_TRACE_STATUS, "Unknown status event "
-				"type %u.\n", dev->status[0]);
+			uvc_trace(dev, UVC_TRACE_STATUS,
+				  "Unknown status event type %u.\n",
+				  dev->status[0]);
 			break;
 		}
 	}
diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
index fa06bfa174ad..3a2d17bc766b 100644
--- a/drivers/media/usb/uvc/uvc_v4l2.c
+++ b/drivers/media/usb/uvc/uvc_v4l2.c
@@ -75,8 +75,9 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
 		break;
 
 	default:
-		uvc_trace(UVC_TRACE_CONTROL, "Unsupported V4L2 control type "
-			  "%u.\n", xmap->v4l2_type);
+		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
+			  "Unsupported V4L2 control type %u.\n",
+			  xmap->v4l2_type);
 		ret = -ENOTTY;
 		goto free_map;
 	}
@@ -164,10 +165,11 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 		return -EINVAL;
 
 	fcc = (u8 *)&fmt->fmt.pix.pixelformat;
-	uvc_trace(UVC_TRACE_FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
-			fmt->fmt.pix.pixelformat,
-			fcc[0], fcc[1], fcc[2], fcc[3],
-			fmt->fmt.pix.width, fmt->fmt.pix.height);
+	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+		  "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
+		  fmt->fmt.pix.pixelformat,
+		  fcc[0], fcc[1], fcc[2], fcc[3],
+		  fmt->fmt.pix.width, fmt->fmt.pix.height);
 
 	/* Check if the hardware supports the requested format, use the default
 	 * format otherwise.
@@ -207,16 +209,18 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (frame == NULL) {
-		uvc_trace(UVC_TRACE_FORMAT, "Unsupported size %ux%u.\n",
-				fmt->fmt.pix.width, fmt->fmt.pix.height);
+		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+			  "Unsupported size %ux%u.\n", fmt->fmt.pix.width,
+			  fmt->fmt.pix.height);
 		return -EINVAL;
 	}
 
 	/* Use the default frame interval. */
 	interval = frame->dwDefaultFrameInterval;
-	uvc_trace(UVC_TRACE_FORMAT, "Using default frame interval %u.%u us "
-		"(%u.%u fps).\n", interval/10, interval%10, 10000000/interval,
-		(100000000/interval)%10);
+	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+		  "Using default frame interval %u.%u us (%u.%u fps).\n",
+		  interval / 10, interval % 10, 10000000 / interval,
+		 (100000000 / interval) % 10);
 
 	/* Set the format index, frame index and frame interval. */
 	memset(probe, 0, sizeof(*probe));
@@ -258,7 +262,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (i == stream->nformats) {
-		uvc_trace(UVC_TRACE_FORMAT, "Unknown bFormatIndex %u\n",
+		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+			  "Unknown bFormatIndex %u\n",
 			  probe->bFormatIndex);
 		return -EINVAL;
 	}
@@ -271,7 +276,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (i == format->nframes) {
-		uvc_trace(UVC_TRACE_FORMAT, "Unknown bFrameIndex %u\n",
+		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+			  "Unknown bFrameIndex %u\n",
 			  probe->bFrameIndex);
 		return -EINVAL;
 	}
@@ -416,8 +422,9 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
 
 	interval = uvc_fraction_to_interval(timeperframe.numerator,
 		timeperframe.denominator);
-	uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n",
-		timeperframe.numerator, timeperframe.denominator, interval);
+	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
+		  "Setting frame interval to %u/%u (%u).\n",
+		  timeperframe.numerator, timeperframe.denominator, interval);
 
 	mutex_lock(&stream->mutex);
 
@@ -545,8 +552,8 @@ static int uvc_v4l2_open(struct file *file)
 	struct uvc_fh *handle;
 	int ret = 0;
 
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_open\n");
 	stream = video_drvdata(file);
+	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
 
 	ret = usb_autopm_get_interface(stream->dev->intf);
 	if (ret < 0)
@@ -588,7 +595,7 @@ static int uvc_v4l2_release(struct file *file)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_release\n");
+	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
 
 	/* Only free resources if this is a privileged handle. */
 	if (uvc_has_privileges(handle))
@@ -1461,7 +1468,11 @@ static long uvc_v4l2_compat_ioctl32(struct file *file,
 static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
 		    size_t count, loff_t *ppos)
 {
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_read: not implemented.\n");
+	struct uvc_fh *handle = file->private_data;
+	struct uvc_streaming *stream = handle->stream;
+
+	uvc_trace(stream->dev, UVC_TRACE_CALLS,
+		  "uvc_v4l2_read: not implemented.\n");
 	return -EINVAL;
 }
 
@@ -1470,7 +1481,7 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n");
+	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
 
 	return uvc_queue_mmap(&stream->queue, vma);
 }
@@ -1480,7 +1491,7 @@ static __poll_t uvc_v4l2_poll(struct file *file, poll_table *wait)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_poll\n");
+	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
 
 	return uvc_queue_poll(&stream->queue, file, wait);
 }
@@ -1493,7 +1504,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_get_unmapped_area\n");
+	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
 
 	return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
 }
diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
index 07baead470fc..e44fcb645516 100644
--- a/drivers/media/usb/uvc/uvc_video.c
+++ b/drivers/media/usb/uvc/uvc_video.c
@@ -95,7 +95,7 @@ int uvc_query_ctrl(struct uvc_device *dev, u8 query, u8 unit,
 	if (ret != 1)
 		return ret < 0 ? ret : -EPIPE;
 
-	uvc_trace(UVC_TRACE_CONTROL, "Control error %u\n", error);
+	uvc_trace(dev, UVC_TRACE_CONTROL, "Control error %u\n", error);
 
 	switch (error) {
 	case 0:
@@ -705,8 +705,8 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
 
 	sof = y;
 
-	uvc_trace(UVC_TRACE_CLOCK, "%s: PTS %u y %llu.%06llu SOF %u.%06llu "
-		  "(x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
+	uvc_trace(stream->dev, UVC_TRACE_CLOCK,
+		  "%s: PTS %u y %llu.%06llu SOF %u.%06llu (x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
 		  stream->dev->name, buf->pts,
 		  y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
 		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
@@ -740,8 +740,8 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
 
 	timestamp = ktime_to_ns(first->host_time) + y - y1;
 
-	uvc_trace(UVC_TRACE_CLOCK, "%s: SOF %u.%06llu y %llu ts %llu "
-		  "buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
+	uvc_trace(stream->dev, UVC_TRACE_CLOCK,
+		  "%s: SOF %u.%06llu y %llu ts %llu buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
 		  stream->dev->name,
 		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
 		  y, timestamp, vbuf->vb2_buf.timestamp,
@@ -875,9 +875,8 @@ static void uvc_video_stats_update(struct uvc_streaming *stream)
 {
 	struct uvc_stats_frame *frame = &stream->stats.frame;
 
-	uvc_trace(UVC_TRACE_STATS, "frame %u stats: %u/%u/%u packets, "
-		  "%u/%u/%u pts (%searly %sinitial), %u/%u scr, "
-		  "last pts/stc/sof %u/%u/%u\n",
+	uvc_trace(stream->dev, UVC_TRACE_STATS,
+		  "frame %u stats: %u/%u/%u packets, %u/%u/%u pts (%searly %sinitial), %u/%u scr, last pts/stc/sof %u/%u/%u\n",
 		  stream->sequence, frame->first_data,
 		  frame->nb_packets - frame->nb_empty, frame->nb_packets,
 		  frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
@@ -1039,8 +1038,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 
 	/* Mark the buffer as bad if the error bit is set. */
 	if (data[1] & UVC_STREAM_ERR) {
-		uvc_trace(UVC_TRACE_FRAME, "Marking buffer as bad (error bit "
-			  "set).\n");
+		uvc_trace(stream->dev, UVC_TRACE_FRAME,
+			  "Marking buffer as bad (error bit set).\n");
 		buf->error = 1;
 	}
 
@@ -1054,8 +1053,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 	 */
 	if (buf->state != UVC_BUF_STATE_ACTIVE) {
 		if (fid == stream->last_fid) {
-			uvc_trace(UVC_TRACE_FRAME, "Dropping payload (out of "
-				"sync).\n");
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "Dropping payload (out of sync).\n");
 			if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
 			    (data[1] & UVC_STREAM_EOF))
 				stream->last_fid ^= UVC_STREAM_FID;
@@ -1086,8 +1085,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 	 * previous payload had the EOF bit set.
 	 */
 	if (fid != stream->last_fid && buf->bytesused != 0) {
-		uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
-				"toggled).\n");
+		uvc_trace(stream->dev, UVC_TRACE_FRAME,
+			  "Frame complete (FID bit toggled).\n");
 		buf->state = UVC_BUF_STATE_READY;
 		return -EAGAIN;
 	}
@@ -1148,7 +1147,8 @@ static void uvc_video_decode_data(struct uvc_urb *uvc_urb,
 
 	/* Complete the current frame if the buffer size was exceeded. */
 	if (len > maxlen) {
-		uvc_trace(UVC_TRACE_FRAME, "Frame complete (overflow).\n");
+		uvc_trace(uvc_urb->stream->dev, UVC_TRACE_FRAME,
+			  "Frame complete (overflow).\n");
 		buf->error = 1;
 		buf->state = UVC_BUF_STATE_READY;
 	}
@@ -1161,9 +1161,11 @@ static void uvc_video_decode_end(struct uvc_streaming *stream,
 {
 	/* Mark the buffer as done if the EOF marker is set. */
 	if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
-		uvc_trace(UVC_TRACE_FRAME, "Frame complete (EOF found).\n");
+		uvc_trace(stream->dev, UVC_TRACE_FRAME,
+			  "Frame complete (EOF found).\n");
 		if (data[0] == len)
-			uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "EOF in empty payload.\n");
 		buf->state = UVC_BUF_STATE_READY;
 		if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
 			stream->last_fid ^= UVC_STREAM_FID;
@@ -1279,7 +1281,7 @@ static void uvc_video_decode_meta(struct uvc_streaming *stream,
 	memcpy(&meta->length, mem, length);
 	meta_buf->bytesused += length + sizeof(meta->ns) + sizeof(meta->sof);
 
-	uvc_trace(UVC_TRACE_FRAME,
+	uvc_trace(stream->dev, UVC_TRACE_FRAME,
 		  "%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n",
 		  __func__, ktime_to_ns(time), meta->sof, meta->length,
 		  meta->flags,
@@ -1339,8 +1341,9 @@ static void uvc_video_decode_isoc(struct uvc_urb *uvc_urb,
 
 	for (i = 0; i < urb->number_of_packets; ++i) {
 		if (urb->iso_frame_desc[i].status < 0) {
-			uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "
-				"lost (%d).\n", urb->iso_frame_desc[i].status);
+			uvc_trace(stream->dev, UVC_TRACE_FRAME,
+				  "USB isochronous frame lost (%d).\n",
+				  urb->iso_frame_desc[i].status);
 			/* Mark the buffer as faulty. */
 			if (buf != NULL)
 				buf->error = 1;
@@ -1628,15 +1631,16 @@ static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
 		}
 
 		if (i == UVC_URBS) {
-			uvc_trace(UVC_TRACE_VIDEO, "Allocated %u URB buffers "
-				"of %ux%u bytes each.\n", UVC_URBS, npackets,
-				psize);
+			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+				  "Allocated %u URB buffers of %ux%u bytes each.\n",
+				  UVC_URBS, npackets, psize);
 			return npackets;
 		}
 	}
 
-	uvc_trace(UVC_TRACE_VIDEO, "Failed to allocate URB buffers (%u bytes "
-		"per packet).\n", psize);
+	uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+		  "Failed to allocate URB buffers (%u bytes per packet).\n",
+		  psize);
 	return 0;
 }
 
@@ -1835,12 +1839,13 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
 		bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
 
 		if (bandwidth == 0) {
-			uvc_trace(UVC_TRACE_VIDEO, "Device requested null "
-				"bandwidth, defaulting to lowest.\n");
+			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+				  "Device requested null bandwidth, defaulting to lowest.\n");
 			bandwidth = 1;
 		} else {
-			uvc_trace(UVC_TRACE_VIDEO, "Device requested %u "
-				"B/frame bandwidth.\n", bandwidth);
+			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+				  "Device requested %u B/frame bandwidth.\n",
+				  bandwidth);
 		}
 
 		for (i = 0; i < intf->num_altsetting; ++i) {
@@ -1863,13 +1868,14 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
 		}
 
 		if (best_ep == NULL) {
-			uvc_trace(UVC_TRACE_VIDEO, "No fast enough alt setting "
-				"for requested bandwidth.\n");
+			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+				  "No fast enough alt setting for requested bandwidth.\n");
 			return -EIO;
 		}
 
-		uvc_trace(UVC_TRACE_VIDEO, "Selecting alternate setting %u "
-			"(%u B/frame bandwidth).\n", altsetting, best_psize);
+		uvc_trace(stream->dev, UVC_TRACE_VIDEO,
+			  "Selecting alternate setting %u (%u B/frame bandwidth).\n",
+			  altsetting, best_psize);
 
 		ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
 		if (ret < 0)
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index a362ba6d5295..63f7e88c5713 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -754,10 +754,11 @@ extern unsigned int uvc_trace_param;
 extern unsigned int uvc_timeout_param;
 extern unsigned int uvc_hw_timestamps_param;
 
-#define uvc_trace(flag, fmt, ...)					\
+#define uvc_trace(_dev, flag, fmt, ...)					\
 do {									\
 	if (uvc_trace_param & flag)					\
-		printk(KERN_DEBUG "uvcvideo: " fmt, ##__VA_ARGS__);	\
+		dev_printk(KERN_DEBUG, &(_dev)->udev->dev, fmt,		\
+			   ##__VA_ARGS__);				\
 } while (0)
 
 #define uvc_trace_cont(flag, fmt, ...)					\
@@ -819,6 +820,12 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 	return vb2_is_streaming(&queue->queue);
 }
 
+static inline struct uvc_streaming *
+uvc_queue_to_stream(struct uvc_video_queue *queue)
+{
+	return container_of(queue, struct uvc_streaming, queue);
+}
+
 /* V4L2 interface */
 extern const struct v4l2_ioctl_ops uvc_ioctl_ops;
 extern const struct v4l2_file_operations uvc_fops;
-- 
2.29.2.729.g45daf8777d-goog

Re: [PATCH v6 11/11] media: uvcvideo: use dev_printk() for uvc_trace()

[Joe Perches]

Perhaps this on top.

trace isn't a good name as it's not a trace mechanism, it is a
typical debug mechanism.

Rename uvc_trace/uvc_trace_cont macros to uvc_dbg/uvc_dbg_cont.
Rename uvc_trace_param to uvc_dbg_param
Rename UVC_TRACE_<FOO> defines to UVC_DBG_<FOO>
Use ## concatenation in uvc_dbg macros to avoid overly long and
repetitive UVC_DBG uses
---
 drivers/media/usb/uvc/uvc_ctrl.c   |  81 +++++----
 drivers/media/usb/uvc/uvc_driver.c | 343 ++++++++++++++++++-------------------
 drivers/media/usb/uvc/uvc_isight.c |  17 +-
 drivers/media/usb/uvc/uvc_queue.c  |   4 +-
 drivers/media/usb/uvc/uvc_status.c |  29 ++--
 drivers/media/usb/uvc/uvc_v4l2.c   |  55 +++---
 drivers/media/usb/uvc/uvc_video.c  | 120 +++++++------
 drivers/media/usb/uvc/uvcvideo.h   |  34 ++--
 8 files changed, 331 insertions(+), 352 deletions(-)

diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index bf448c213c53..7b70877b2483 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -906,8 +906,8 @@ static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
 	}
 
 	if (ctrl == NULL && !next)
-		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
-			  "Control 0x%08x not found.\n", v4l2_id);
+		uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",
+			v4l2_id);
 
 	return ctrl;
 }
@@ -1820,9 +1820,9 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 	ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id, dev->intfnum,
 			     info->selector, data, 2);
 	if (ret < 0) {
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "GET_LEN failed on control %pUl/%u (%d).\n",
-			  info->entity, info->selector, ret);
+		uvc_dbg(dev, CONTROL,
+			"GET_LEN failed on control %pUl/%u (%d)\n",
+			info->entity, info->selector, ret);
 		goto done;
 	}
 
@@ -1833,20 +1833,20 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
 
 	ret = uvc_ctrl_get_flags(dev, ctrl, info);
 	if (ret < 0) {
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "Failed to get flags for control %pUl/%u (%d).\n",
-			  info->entity, info->selector, ret);
+		uvc_dbg(dev, CONTROL,
+			"Failed to get flags for control %pUl/%u (%d)\n",
+			info->entity, info->selector, ret);
 		goto done;
 	}
 
 	uvc_ctrl_fixup_xu_info(dev, ctrl, info);
 
-	uvc_trace(dev, UVC_TRACE_CONTROL,
-		  "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }.\n",
-		  info->entity, info->selector, info->size,
-		  (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
-		  (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
-		  (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
+	uvc_dbg(dev, CONTROL,
+		"XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }\n",
+		info->entity, info->selector, info->size,
+		(info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
+		(info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
+		(info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
 
 done:
 	kfree(data);
@@ -1871,10 +1871,10 @@ static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
 
 	ret = uvc_ctrl_add_info(dev, ctrl, &info);
 	if (ret < 0)
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "Failed to initialize control %pUl/%u on device %s entity %u\n",
-			  info.entity, info.selector, dev->udev->devpath,
-			  ctrl->entity->id);
+		uvc_dbg(dev, CONTROL,
+			"Failed to initialize control %pUl/%u on device %s entity %u\n",
+			info.entity, info.selector, dev->udev->devpath,
+			ctrl->entity->id);
 
 	return ret;
 }
@@ -1902,8 +1902,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
 	}
 
 	if (!found) {
-		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
-			  "Extension unit %u not found.\n", xqry->unit);
+		uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",
+			xqry->unit);
 		return -ENOENT;
 	}
 
@@ -1918,9 +1918,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
 	}
 
 	if (!found) {
-		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
-			  "Control %pUl/%u not found.\n", entity->guid,
-			  xqry->selector);
+		uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",
+			entity->guid, xqry->selector);
 		return -ENOENT;
 	}
 
@@ -2068,10 +2067,9 @@ static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
 
 	ctrl->initialized = 1;
 
-	uvc_trace(dev, UVC_TRACE_CONTROL,
-		  "Added control %pUl/%u to device %s entity %u\n",
-		  ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
-		  ctrl->entity->id);
+	uvc_dbg(dev, CONTROL, "Added control %pUl/%u to device %s entity %u\n",
+		ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
+		ctrl->entity->id);
 
 	return 0;
 }
@@ -2108,9 +2106,8 @@ static int __uvc_ctrl_add_mapping(struct uvc_device *dev,
 		map->set = uvc_set_le_value;
 
 	list_add_tail(&map->list, &ctrl->info.mappings);
-	uvc_trace(dev, UVC_TRACE_CONTROL,
-		  "Adding mapping '%s' to control %pUl/%u.\n",
-		  map->name, ctrl->info.entity, ctrl->info.selector);
+	uvc_dbg(dev, CONTROL, "Adding mapping '%s' to control %pUl/%u\n",
+		map->name, ctrl->info.entity, ctrl->info.selector);
 
 	return 0;
 }
@@ -2126,9 +2123,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 	int ret;
 
 	if (mapping->id & ~V4L2_CTRL_ID_MASK) {
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "Can't add mapping '%s', control id 0x%08x is invalid.\n",
-			  mapping->name, mapping->id);
+		uvc_dbg(dev, CONTROL,
+			"Can't add mapping '%s', control id 0x%08x is invalid\n",
+			mapping->name, mapping->id);
 		return -EINVAL;
 	}
 
@@ -2173,9 +2170,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 
 	list_for_each_entry(map, &ctrl->info.mappings, list) {
 		if (mapping->id == map->id) {
-			uvc_trace(dev, UVC_TRACE_CONTROL,
-				  "Can't add mapping '%s', control id 0x%08x already exists.\n",
-				  mapping->name, mapping->id);
+			uvc_dbg(dev, CONTROL,
+				"Can't add mapping '%s', control id 0x%08x already exists\n",
+				mapping->name, mapping->id);
 			ret = -EEXIST;
 			goto done;
 		}
@@ -2184,9 +2181,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
 	/* Prevent excess memory consumption */
 	if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
 		atomic_dec(&dev->nmappings);
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "Can't add mapping '%s', maximum mappings count (%u) exceeded.\n",
-			  mapping->name, UVC_MAX_CONTROL_MAPPINGS);
+		uvc_dbg(dev, CONTROL,
+			"Can't add mapping '%s', maximum mappings count (%u) exceeded\n",
+			mapping->name, UVC_MAX_CONTROL_MAPPINGS);
 		ret = -ENOMEM;
 		goto done;
 	}
@@ -2255,9 +2252,9 @@ static void uvc_ctrl_prune_entity(struct uvc_device *dev,
 		    !uvc_test_bit(controls, blacklist[i].index))
 			continue;
 
-		uvc_trace(dev, UVC_TRACE_CONTROL,
-			  "%u/%u control is black listed, removing it.\n",
-			  entity->id, blacklist[i].index);
+		uvc_dbg(dev, CONTROL,
+			"%u/%u control is black listed, removing it\n",
+			entity->id, blacklist[i].index);
 
 		uvc_clear_bit(controls, blacklist[i].index);
 	}
diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
index 1f72bda6036e..2dbed5c3831a 100644
--- a/drivers/media/usb/uvc/uvc_driver.c
+++ b/drivers/media/usb/uvc/uvc_driver.c
@@ -33,7 +33,7 @@ unsigned int uvc_clock_param = CLOCK_MONOTONIC;
 unsigned int uvc_hw_timestamps_param;
 unsigned int uvc_no_drop_param;
 static unsigned int uvc_quirks_param = -1;
-unsigned int uvc_trace_param;
+unsigned int uvc_dbg_param;
 unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
 
 /* ------------------------------------------------------------------------
@@ -521,10 +521,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 	case UVC_VS_FORMAT_FRAME_BASED:
 		n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
 		if (buflen < n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d FORMAT error\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d FORMAT error\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -585,10 +585,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 
 	case UVC_VS_FORMAT_MJPEG:
 		if (buflen < 11) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d FORMAT error\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d FORMAT error\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -601,10 +601,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 
 	case UVC_VS_FORMAT_DV:
 		if (buflen < 9) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d FORMAT error\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d FORMAT error\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -619,10 +619,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 			strscpy(format->name, "HD-DV", sizeof(format->name));
 			break;
 		default:
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d: unknown DV format %u\n",
-				  dev->udev->devnum,
-			       alts->desc.bInterfaceNumber, buffer[8]);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d: unknown DV format %u\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber, buffer[8]);
 			return -EINVAL;
 		}
 
@@ -648,14 +648,14 @@ static int uvc_parse_format(struct uvc_device *dev,
 	case UVC_VS_FORMAT_STREAM_BASED:
 		/* Not supported yet. */
 	default:
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d videostreaming interface %d unsupported format %u\n",
-			  dev->udev->devnum, alts->desc.bInterfaceNumber,
-			  buffer[2]);
+		uvc_dbg(dev, DESCR,
+			"device %d videostreaming interface %d unsupported format %u\n",
+			dev->udev->devnum, alts->desc.bInterfaceNumber,
+			buffer[2]);
 		return -EINVAL;
 	}
 
-	uvc_trace(dev, UVC_TRACE_DESCR, "Found format %s.\n", format->name);
+	uvc_dbg(dev, DESCR, "Found format %s\n", format->name);
 
 	buflen -= buffer[0];
 	buffer += buffer[0];
@@ -674,10 +674,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 		n = n ? n : 3;
 
 		if (buflen < 26 + 4*n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d FRAME error\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d FRAME error\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -739,10 +739,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 				frame->dwDefaultFrameInterval;
 		}
 
-		uvc_trace(dev, UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
-			  frame->wWidth, frame->wHeight,
-			  10000000 / frame->dwDefaultFrameInterval,
-			  (100000000 / frame->dwDefaultFrameInterval) % 10);
+		uvc_dbg(dev, DESCR, "- %ux%u (%u.%u fps)\n",
+			frame->wWidth, frame->wHeight,
+			10000000 / frame->dwDefaultFrameInterval,
+			(100000000 / frame->dwDefaultFrameInterval) % 10);
 
 		format->nframes++;
 		buflen -= buffer[0];
@@ -758,10 +758,10 @@ static int uvc_parse_format(struct uvc_device *dev,
 	if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
 	    buffer[2] == UVC_VS_COLORFORMAT) {
 		if (buflen < 6) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d COLORFORMAT error\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d COLORFORMAT error\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -793,18 +793,18 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 	if (intf->cur_altsetting->desc.bInterfaceSubClass
 		!= UVC_SC_VIDEOSTREAMING) {
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d interface %d isn't a video streaming interface\n",
-			  dev->udev->devnum,
-			  intf->altsetting[0].desc.bInterfaceNumber);
+		uvc_dbg(dev, DESCR,
+			"device %d interface %d isn't a video streaming interface\n",
+			dev->udev->devnum,
+			intf->altsetting[0].desc.bInterfaceNumber);
 		return -EINVAL;
 	}
 
 	if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d interface %d is already claimed\n",
-			  dev->udev->devnum,
-			  intf->altsetting[0].desc.bInterfaceNumber);
+		uvc_dbg(dev, DESCR,
+			"device %d interface %d is already claimed\n",
+			dev->udev->devnum,
+			intf->altsetting[0].desc.bInterfaceNumber);
 		return -EINVAL;
 	}
 
@@ -826,9 +826,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 			if (ep->extralen > 2 &&
 			    ep->extra[1] == USB_DT_CS_INTERFACE) {
-				uvc_trace(dev, UVC_TRACE_DESCR,
-					  "trying extra data from endpoint %u.\n",
-					  i);
+				uvc_dbg(dev, DESCR,
+					"trying extra data from endpoint %u\n",
+					i);
 				buffer = alts->endpoint[i].extra;
 				buflen = alts->endpoint[i].extralen;
 				break;
@@ -843,8 +843,8 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (buflen <= 2) {
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "no class-specific streaming interface descriptors found.\n");
+		uvc_dbg(dev, DESCR,
+			"no class-specific streaming interface descriptors found\n");
 		goto error;
 	}
 
@@ -861,9 +861,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 		break;
 
 	default:
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d videostreaming interface %d HEADER descriptor not found.\n",
-			  dev->udev->devnum, alts->desc.bInterfaceNumber);
+		uvc_dbg(dev, DESCR,
+			"device %d videostreaming interface %d HEADER descriptor not found\n",
+			dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -871,9 +871,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	n = buflen >= size ? buffer[size-1] : 0;
 
 	if (buflen < size + p*n) {
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d videostreaming interface %d HEADER descriptor is invalid.\n",
-			  dev->udev->devnum, alts->desc.bInterfaceNumber);
+		uvc_dbg(dev, DESCR,
+			"device %d videostreaming interface %d HEADER descriptor is invalid\n",
+			dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -923,10 +923,10 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 
 		case UVC_VS_FORMAT_MPEG2TS:
 		case UVC_VS_FORMAT_STREAM_BASED:
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videostreaming interface %d FORMAT %u is not supported.\n",
-				  dev->udev->devnum,
-				  alts->desc.bInterfaceNumber, _buffer[2]);
+			uvc_dbg(dev, DESCR,
+				"device %d videostreaming interface %d FORMAT %u is not supported\n",
+				dev->udev->devnum,
+				alts->desc.bInterfaceNumber, _buffer[2]);
 			break;
 
 		case UVC_VS_FRAME_UNCOMPRESSED:
@@ -948,9 +948,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (nformats == 0) {
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d videostreaming interface %d has no supported formats defined.\n",
-			  dev->udev->devnum, alts->desc.bInterfaceNumber);
+		uvc_dbg(dev, DESCR,
+			"device %d videostreaming interface %d has no supported formats defined\n",
+			dev->udev->devnum, alts->desc.bInterfaceNumber);
 		goto error;
 	}
 
@@ -997,10 +997,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
 	}
 
 	if (buflen)
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage.\n",
-			  dev->udev->devnum, alts->desc.bInterfaceNumber,
-			  buflen);
+		uvc_dbg(dev, DESCR,
+			"device %d videostreaming interface %d has %u bytes of trailing descriptor garbage\n",
+			dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
 
 	/* Parse the alternate settings to find the maximum bandwidth. */
 	for (i = 0; i < intf->num_altsetting; ++i) {
@@ -1133,9 +1132,9 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
 		n = buflen >= 25 + p ? buffer[22+p] : 0;
 
 		if (buflen < 25 + p + 2*n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d EXTENSION_UNIT error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d EXTENSION_UNIT error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			break;
 		}
 
@@ -1182,9 +1181,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		n = buflen >= 12 ? buffer[11] : 0;
 
 		if (buflen < 12 + n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d HEADER error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d HEADER error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1195,9 +1194,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		for (i = 0; i < n; ++i) {
 			intf = usb_ifnum_to_if(udev, buffer[12+i]);
 			if (intf == NULL) {
-				uvc_trace(dev, UVC_TRACE_DESCR,
-					  "device %d interface %d doesn't exists\n",
-					  udev->devnum, i);
+				uvc_dbg(dev, DESCR,
+					"device %d interface %d doesn't exists\n",
+					udev->devnum, i);
 				continue;
 			}
 
@@ -1207,9 +1206,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 
 	case UVC_VC_INPUT_TERMINAL:
 		if (buflen < 8) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d INPUT_TERMINAL error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d INPUT_TERMINAL error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1226,10 +1225,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		 */
 		type = get_unaligned_le16(&buffer[4]);
 		if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
-				  udev->devnum, alts->desc.bInterfaceNumber,
-				  buffer[3], type);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
+				udev->devnum, alts->desc.bInterfaceNumber,
+				buffer[3], type);
 			return 0;
 		}
 
@@ -1248,9 +1247,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		}
 
 		if (buflen < len + n + p) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d INPUT_TERMINAL error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d INPUT_TERMINAL error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1295,9 +1294,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 
 	case UVC_VC_OUTPUT_TERMINAL:
 		if (buflen < 9) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1306,10 +1305,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		 */
 		type = get_unaligned_le16(&buffer[4]);
 		if ((type & 0xff00) == 0) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
-				  udev->devnum, alts->desc.bInterfaceNumber,
-				  buffer[3], type);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
+				udev->devnum, alts->desc.bInterfaceNumber,
+				buffer[3], type);
 			return 0;
 		}
 
@@ -1333,9 +1332,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		p = buflen >= 5 ? buffer[4] : 0;
 
 		if (buflen < 5 || buflen < 6 + p) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d SELECTOR_UNIT error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d SELECTOR_UNIT error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1359,9 +1358,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		p = dev->uvc_version >= 0x0110 ? 10 : 9;
 
 		if (buflen < p + n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d PROCESSING_UNIT error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d PROCESSING_UNIT error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1392,9 +1391,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		n = buflen >= 24 + p ? buffer[22+p] : 0;
 
 		if (buflen < 24 + p + n) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "device %d videocontrol interface %d EXTENSION_UNIT error\n",
-				  udev->devnum, alts->desc.bInterfaceNumber);
+			uvc_dbg(dev, DESCR,
+				"device %d videocontrol interface %d EXTENSION_UNIT error\n",
+				udev->devnum, alts->desc.bInterfaceNumber);
 			return -EINVAL;
 		}
 
@@ -1419,9 +1418,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
 		break;
 
 	default:
-		uvc_trace(dev, UVC_TRACE_DESCR,
-			  "Found an unknown CS_INTERFACE descriptor (%u)\n",
-			  buffer[2]);
+		uvc_dbg(dev, DESCR,
+			"Found an unknown CS_INTERFACE descriptor (%u)\n",
+			buffer[2]);
 		break;
 	}
 
@@ -1466,9 +1465,9 @@ static int uvc_parse_control(struct uvc_device *dev)
 		if (usb_endpoint_is_int_in(desc) &&
 		    le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
 		    desc->bInterval != 0) {
-			uvc_trace(dev, UVC_TRACE_DESCR,
-				  "Found a Status endpoint (addr %02x).\n",
-				  desc->bEndpointAddress);
+			uvc_dbg(dev, DESCR,
+				"Found a Status endpoint (addr %02x)\n",
+				desc->bEndpointAddress);
 			dev->int_ep = ep;
 		}
 	}
@@ -1652,23 +1651,23 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 {
 	switch (UVC_ENTITY_TYPE(entity)) {
 	case UVC_VC_EXTENSION_UNIT:
-		uvc_trace_cont(UVC_TRACE_PROBE, " <- XU %d", entity->id);
+		uvc_dbg_cont(PROBE, " <- XU %d", entity->id);
 
 		if (entity->bNrInPins != 1) {
-			uvc_trace(chain->dev, UVC_TRACE_DESCR,
-				  "Extension unit %d has more than 1 input pin.\n",
-				  entity->id);
+			uvc_dbg(chain->dev, DESCR,
+				"Extension unit %d has more than 1 input pin\n",
+				entity->id);
 			return -1;
 		}
 
 		break;
 
 	case UVC_VC_PROCESSING_UNIT:
-		uvc_trace_cont(UVC_TRACE_PROBE, " <- PU %d", entity->id);
+		uvc_dbg_cont(PROBE, " <- PU %d", entity->id);
 
 		if (chain->processing != NULL) {
-			uvc_trace(chain->dev, UVC_TRACE_DESCR,
-				  "Found multiple Processing Units in chain.\n");
+			uvc_dbg(chain->dev, DESCR,
+				"Found multiple Processing Units in chain\n");
 			return -1;
 		}
 
@@ -1676,15 +1675,15 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 		break;
 
 	case UVC_VC_SELECTOR_UNIT:
-		uvc_trace_cont(UVC_TRACE_PROBE, " <- SU %d", entity->id);
+		uvc_dbg_cont(PROBE, " <- SU %d", entity->id);
 
 		/* Single-input selector units are ignored. */
 		if (entity->bNrInPins == 1)
 			break;
 
 		if (chain->selector != NULL) {
-			uvc_trace(chain->dev, UVC_TRACE_DESCR,
-				  "Found multiple Selector Units in chain.\n");
+			uvc_dbg(chain->dev, DESCR,
+				"Found multiple Selector Units in chain\n");
 			return -1;
 		}
 
@@ -1694,29 +1693,29 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
 	case UVC_ITT_VENDOR_SPECIFIC:
 	case UVC_ITT_CAMERA:
 	case UVC_ITT_MEDIA_TRANSPORT_INPUT:
-		uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
+		uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id);
 
 		break;
 
 	case UVC_OTT_VENDOR_SPECIFIC:
 	case UVC_OTT_DISPLAY:
 	case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
-		uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
+		uvc_dbg_cont(PROBE, " OT %d", entity->id);
 
 		break;
 
 	case UVC_TT_STREAMING:
 		if (UVC_ENTITY_IS_ITERM(entity))
-			uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
+			uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id);
 		else
-			uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
+			uvc_dbg_cont(PROBE, " OT %d", entity->id);
 
 		break;
 
 	default:
-		uvc_trace(chain->dev, UVC_TRACE_DESCR,
-			  "Unsupported entity type 0x%04x found in chain.\n",
-			  UVC_ENTITY_TYPE(entity));
+		uvc_dbg(chain->dev, DESCR,
+			"Unsupported entity type 0x%04x found in chain\n",
+			UVC_ENTITY_TYPE(entity));
 		return -1;
 	}
 
@@ -1742,26 +1741,26 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 		if (forward == prev)
 			continue;
 		if (forward->chain.next || forward->chain.prev) {
-			uvc_trace(chain->dev, UVC_TRACE_DESCR,
-				  "Found reference to entity %d already in chain.\n",
-				  forward->id);
+			uvc_dbg(chain->dev, DESCR,
+				"Found reference to entity %d already in chain\n",
+				forward->id);
 			return -EINVAL;
 		}
 
 		switch (UVC_ENTITY_TYPE(forward)) {
 		case UVC_VC_EXTENSION_UNIT:
 			if (forward->bNrInPins != 1) {
-				uvc_trace(chain->dev, UVC_TRACE_DESCR,
-					  "Extension unit %d has more than 1 input pin.\n",
-					  entity->id);
+				uvc_dbg(chain->dev, DESCR,
+					"Extension unit %d has more than 1 input pin\n",
+					entity->id);
 				return -EINVAL;
 			}
 
 			list_add_tail(&forward->chain, &chain->entities);
 			if (!found)
-				uvc_trace_cont(UVC_TRACE_PROBE, " (->");
+				uvc_dbg_cont(PROBE, " (->");
 
-			uvc_trace_cont(UVC_TRACE_PROBE, " XU %d", forward->id);
+			uvc_dbg_cont(PROBE, " XU %d", forward->id);
 			found = 1;
 			break;
 
@@ -1770,23 +1769,23 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
 		case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
 		case UVC_TT_STREAMING:
 			if (UVC_ENTITY_IS_ITERM(forward)) {
-				uvc_trace(chain->dev, UVC_TRACE_DESCR,
-					  "Unsupported input terminal %u.\n",
-					  forward->id);
+				uvc_dbg(chain->dev, DESCR,
+					"Unsupported input terminal %u\n",
+					forward->id);
 				return -EINVAL;
 			}
 
 			list_add_tail(&forward->chain, &chain->entities);
 			if (!found)
-				uvc_trace_cont(UVC_TRACE_PROBE, " (->");
+				uvc_dbg_cont(PROBE, " (->");
 
-			uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", forward->id);
+			uvc_dbg_cont(PROBE, " OT %d", forward->id);
 			found = 1;
 			break;
 		}
 	}
 	if (found)
-		uvc_trace_cont(UVC_TRACE_PROBE, ")");
+		uvc_dbg_cont(PROBE, ")");
 
 	return 0;
 }
@@ -1811,33 +1810,33 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 			break;
 		}
 
-		uvc_trace_cont(UVC_TRACE_PROBE, " <- IT");
+		uvc_dbg_cont(PROBE, " <- IT");
 
 		chain->selector = entity;
 		for (i = 0; i < entity->bNrInPins; ++i) {
 			id = entity->baSourceID[i];
 			term = uvc_entity_by_id(chain->dev, id);
 			if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
-				uvc_trace(chain->dev, UVC_TRACE_DESCR,
-					  "Selector unit %d input %d isn't connected to an input terminal\n",
-					  entity->id, i);
+				uvc_dbg(chain->dev, DESCR,
+					"Selector unit %d input %d isn't connected to an input terminal\n",
+					entity->id, i);
 				return -1;
 			}
 
 			if (term->chain.next || term->chain.prev) {
-				uvc_trace(chain->dev, UVC_TRACE_DESCR,
-					  "Found reference to entity %d already in chain.\n",
-					  term->id);
+				uvc_dbg(chain->dev, DESCR,
+					"Found reference to entity %d already in chain\n",
+					term->id);
 				return -EINVAL;
 			}
 
-			uvc_trace_cont(UVC_TRACE_PROBE, " %d", term->id);
+			uvc_dbg_cont(PROBE, " %d", term->id);
 
 			list_add_tail(&term->chain, &chain->entities);
 			uvc_scan_chain_forward(chain, term, entity);
 		}
 
-		uvc_trace_cont(UVC_TRACE_PROBE, "\n");
+		uvc_dbg_cont(PROBE, "\n");
 
 		id = 0;
 		break;
@@ -1860,8 +1859,8 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
 
 	entity = uvc_entity_by_id(chain->dev, id);
 	if (entity == NULL) {
-		uvc_trace(chain->dev, UVC_TRACE_DESCR,
-			  "Found reference to unknown entity %d.\n", id);
+		uvc_dbg(chain->dev, DESCR,
+			"Found reference to unknown entity %d\n", id);
 		return -EINVAL;
 	}
 
@@ -1874,7 +1873,7 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
 {
 	struct uvc_entity *entity, *prev;
 
-	uvc_trace(chain->dev, UVC_TRACE_PROBE, "Scanning UVC chain:");
+	uvc_dbg(chain->dev, PROBE, "Scanning UVC chain:");
 
 	entity = term;
 	prev = NULL;
@@ -1882,9 +1881,9 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
 	while (entity != NULL) {
 		/* Entity must not be part of an existing chain */
 		if (entity->chain.next || entity->chain.prev) {
-			uvc_trace(chain->dev, UVC_TRACE_DESCR,
-				  "Found reference to entity %d already in chain.\n",
-				  entity->id);
+			uvc_dbg(chain->dev, DESCR,
+				"Found reference to entity %d already in chain\n",
+				entity->id);
 			return -EINVAL;
 		}
 
@@ -2038,9 +2037,8 @@ static int uvc_scan_fallback(struct uvc_device *dev)
 
 	list_add_tail(&chain->list, &dev->chains);
 
-	uvc_trace(dev, UVC_TRACE_PROBE,
-		  "Found a video chain by fallback heuristic (%s).\n",
-		  uvc_print_chain(chain));
+	uvc_dbg(dev, PROBE, "Found a video chain by fallback heuristic (%s)\n",
+		uvc_print_chain(chain));
 
 	return 0;
 
@@ -2082,9 +2080,8 @@ static int uvc_scan_device(struct uvc_device *dev)
 			continue;
 		}
 
-		uvc_trace(dev, UVC_TRACE_PROBE,
-			  "Found a valid video chain (%s).\n",
-			  uvc_print_chain(chain));
+		uvc_dbg(dev, PROBE, "Found a valid video chain (%s)\n",
+			uvc_print_chain(chain));
 
 		list_add_tail(&chain->list, &dev->chains);
 	}
@@ -2384,12 +2381,11 @@ static int uvc_probe(struct usb_interface *intf,
 		    ? dev->info->quirks : uvc_quirks_param;
 
 	if (id->idVendor && id->idProduct)
-		uvc_trace(dev, UVC_TRACE_PROBE,
-			  "Probing known UVC device %s (%04x:%04x)\n",
-			  udev->devpath, id->idVendor, id->idProduct);
+		uvc_dbg(dev, PROBE, "Probing known UVC device %s (%04x:%04x)\n",
+			udev->devpath, id->idVendor, id->idProduct);
 	else
-		uvc_trace(dev, UVC_TRACE_PROBE,
-			  "Probing generic UVC device %s\n", udev->devpath);
+		uvc_dbg(dev, PROBE, "Probing generic UVC device %s\n",
+			udev->devpath);
 
 	if (udev->product != NULL)
 		strscpy(dev->name, udev->product, sizeof(dev->name));
@@ -2433,14 +2429,13 @@ static int uvc_probe(struct usb_interface *intf,
 
 	/* Parse the Video Class control descriptor. */
 	if (uvc_parse_control(dev) < 0) {
-		uvc_trace(dev, UVC_TRACE_PROBE,
-			  "Unable to parse UVC descriptors.\n");
+		uvc_dbg(dev, PROBE, "Unable to parse UVC descriptors\n");
 		goto error;
 	}
 
 	/* Parse the associated GPIOs. */
 	if (uvc_gpio_parse(dev) < 0) {
-		uvc_trace(dev, UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
+		uvc_dbg(dev, PROBE, "Unable to parse UVC GPIOs\n");
 		goto error;
 	}
 
@@ -2495,7 +2490,7 @@ static int uvc_probe(struct usb_interface *intf,
 			 "Unable to request privacy GPIO IRQ %d. Continuing without privacy events\n",
 			 ret);
 
-	uvc_trace(dev, UVC_TRACE_PROBE, "UVC device initialized.\n");
+	uvc_dbg(dev, PROBE, "UVC device initialized\n");
 	usb_enable_autosuspend(udev);
 	return 0;
 
@@ -2527,7 +2522,7 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 	struct uvc_device *dev = usb_get_intfdata(intf);
 	struct uvc_streaming *stream;
 
-	uvc_trace(dev, UVC_TRACE_SUSPEND, "Suspending interface %u\n",
+	uvc_dbg(dev, SUSPEND, "Suspending interface %u\n",
 		intf->cur_altsetting->desc.bInterfaceNumber);
 
 	/* Controls are cached on the fly so they don't need to be saved. */
@@ -2545,8 +2540,8 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 			return uvc_video_suspend(stream);
 	}
 
-	uvc_trace(dev, UVC_TRACE_SUSPEND,
-		  "Suspend: video streaming USB interface mismatch.\n");
+	uvc_dbg(dev, SUSPEND,
+		"Suspend: video streaming USB interface mismatch\n");
 	return -EINVAL;
 }
 
@@ -2556,8 +2551,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 	struct uvc_streaming *stream;
 	int ret = 0;
 
-	uvc_trace(dev, UVC_TRACE_SUSPEND, "Resuming interface %u\n",
-		  intf->cur_altsetting->desc.bInterfaceNumber);
+	uvc_dbg(dev, SUSPEND, "Resuming interface %u\n",
+		intf->cur_altsetting->desc.bInterfaceNumber);
 
 	if (intf->cur_altsetting->desc.bInterfaceSubClass ==
 	    UVC_SC_VIDEOCONTROL) {
@@ -2585,8 +2580,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
 		}
 	}
 
-	uvc_trace(dev, UVC_TRACE_SUSPEND,
-		  "Resume: video streaming USB interface mismatch.\n");
+	uvc_dbg(dev, SUSPEND,
+		"Resume: video streaming USB interface mismatch\n");
 	return -EINVAL;
 }
 
@@ -2636,7 +2631,7 @@ module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
 module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(quirks, "Forced device quirks");
-module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
+module_param_named(trace, uvc_dbg_param, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(trace, "Trace level bitmask");
 module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
diff --git a/drivers/media/usb/uvc/uvc_isight.c b/drivers/media/usb/uvc/uvc_isight.c
index 445c4d39aeff..2578d6ee4829 100644
--- a/drivers/media/usb/uvc/uvc_isight.c
+++ b/drivers/media/usb/uvc/uvc_isight.c
@@ -50,16 +50,15 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
 
 	if ((len >= 14 && memcmp(&data[2], hdr, 12) == 0) ||
 	    (len >= 15 && memcmp(&data[3], hdr, 12) == 0)) {
-		uvc_trace(stream->dev, UVC_TRACE_FRAME,
-			  "iSight header found\n");
+		uvc_dbg(stream->dev, FRAME, "iSight header found\n");
 		is_header = 1;
 	}
 
 	/* Synchronize to the input stream by waiting for a header packet. */
 	if (buf->state != UVC_BUF_STATE_ACTIVE) {
 		if (!is_header) {
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "Dropping packet (out of sync).\n");
+			uvc_dbg(stream->dev, FRAME,
+				"Dropping packet (out of sync)\n");
 			return 0;
 		}
 
@@ -87,8 +86,8 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
 		buf->bytesused += nbytes;
 
 		if (len > maxlen || buf->bytesused == buf->length) {
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "Frame complete (overflow).\n");
+			uvc_dbg(stream->dev, FRAME,
+				"Frame complete (overflow)\n");
 			buf->state = UVC_BUF_STATE_DONE;
 		}
 	}
@@ -105,9 +104,9 @@ void uvc_video_decode_isight(struct uvc_urb *uvc_urb, struct uvc_buffer *buf,
 
 	for (i = 0; i < urb->number_of_packets; ++i) {
 		if (urb->iso_frame_desc[i].status < 0) {
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "USB isochronous frame lost (%d).\n",
-				  urb->iso_frame_desc[i].status);
+			uvc_dbg(stream->dev, FRAME,
+				"USB isochronous frame lost (%d)\n",
+				urb->iso_frame_desc[i].status);
 		}
 
 		/* Decode the payload packet.
diff --git a/drivers/media/usb/uvc/uvc_queue.c b/drivers/media/usb/uvc/uvc_queue.c
index 2255daa3e240..21a907d32bb7 100644
--- a/drivers/media/usb/uvc/uvc_queue.c
+++ b/drivers/media/usb/uvc/uvc_queue.c
@@ -103,8 +103,8 @@ static int uvc_buffer_prepare(struct vb2_buffer *vb)
 
 	if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 	    vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
-		uvc_trace(uvc_queue_to_stream(queue)->dev, UVC_TRACE_CAPTURE,
-			  "[E] Bytes used out of bounds.\n");
+		uvc_dbg(uvc_queue_to_stream(queue)->dev, CAPTURE,
+			"[E] Bytes used out of bounds\n");
 		return -EINVAL;
 	}
 
diff --git a/drivers/media/usb/uvc/uvc_status.c b/drivers/media/usb/uvc/uvc_status.c
index b5f493216fcd..d65666bc68f3 100644
--- a/drivers/media/usb/uvc/uvc_status.c
+++ b/drivers/media/usb/uvc/uvc_status.c
@@ -93,22 +93,21 @@ static void uvc_event_streaming(struct uvc_device *dev,
 				struct uvc_streaming_status *status, int len)
 {
 	if (len < 3) {
-		uvc_trace(dev, UVC_TRACE_STATUS,
-			  "Invalid streaming status event received.\n");
+		uvc_dbg(dev, STATUS,
+			"Invalid streaming status event received\n");
 		return;
 	}
 
 	if (status->bEvent == 0) {
 		if (len < 4)
 			return;
-		uvc_trace(dev, UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
-			  status->bOriginator,
-			  status->bValue[0] ? "pressed" : "released", len);
+		uvc_dbg(dev, STATUS, "Button (intf %u) %s len %d\n",
+			status->bOriginator,
+			status->bValue[0] ? "pressed" : "released", len);
 		uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]);
 	} else {
-		uvc_trace(dev, UVC_TRACE_STATUS,
-			  "Stream %u error event %02x len %d.\n",
-			  status->bOriginator, status->bEvent, len);
+		uvc_dbg(dev, STATUS, "Stream %u error event %02x len %d\n",
+			status->bOriginator, status->bEvent, len);
 	}
 }
 
@@ -163,14 +162,13 @@ static bool uvc_event_control(struct urb *urb,
 
 	if (len < 6 || status->bEvent != 0 ||
 	    status->bAttribute >= ARRAY_SIZE(attrs)) {
-		uvc_trace(dev, UVC_TRACE_STATUS,
-			  "Invalid control status event received.\n");
+		uvc_dbg(dev, STATUS, "Invalid control status event received\n");
 		return false;
 	}
 
-	uvc_trace(dev, UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
-		  status->bOriginator, status->bSelector,
-		  attrs[status->bAttribute], len);
+	uvc_dbg(dev, STATUS, "Control %u/%u %s change len %d\n",
+		status->bOriginator, status->bSelector,
+		attrs[status->bAttribute], len);
 
 	/* Find the control. */
 	ctrl = uvc_event_find_ctrl(dev, status, &chain);
@@ -236,9 +234,8 @@ static void uvc_status_complete(struct urb *urb)
 		}
 
 		default:
-			uvc_trace(dev, UVC_TRACE_STATUS,
-				  "Unknown status event type %u.\n",
-				  dev->status[0]);
+			uvc_dbg(dev, STATUS, "Unknown status event type %u\n",
+				dev->status[0]);
 			break;
 		}
 	}
diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
index 3a2d17bc766b..2b8cbb4730e0 100644
--- a/drivers/media/usb/uvc/uvc_v4l2.c
+++ b/drivers/media/usb/uvc/uvc_v4l2.c
@@ -75,9 +75,8 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
 		break;
 
 	default:
-		uvc_trace(chain->dev, UVC_TRACE_CONTROL,
-			  "Unsupported V4L2 control type %u.\n",
-			  xmap->v4l2_type);
+		uvc_dbg(chain->dev, CONTROL,
+			"Unsupported V4L2 control type %u\n", xmap->v4l2_type);
 		ret = -ENOTTY;
 		goto free_map;
 	}
@@ -165,11 +164,10 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 		return -EINVAL;
 
 	fcc = (u8 *)&fmt->fmt.pix.pixelformat;
-	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-		  "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
-		  fmt->fmt.pix.pixelformat,
-		  fcc[0], fcc[1], fcc[2], fcc[3],
-		  fmt->fmt.pix.width, fmt->fmt.pix.height);
+	uvc_dbg(stream->dev, FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u\n",
+		fmt->fmt.pix.pixelformat,
+		fcc[0], fcc[1], fcc[2], fcc[3],
+		fmt->fmt.pix.width, fmt->fmt.pix.height);
 
 	/* Check if the hardware supports the requested format, use the default
 	 * format otherwise.
@@ -209,18 +207,17 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (frame == NULL) {
-		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-			  "Unsupported size %ux%u.\n", fmt->fmt.pix.width,
-			  fmt->fmt.pix.height);
+		uvc_dbg(stream->dev, FORMAT, "Unsupported size %ux%u\n",
+			fmt->fmt.pix.width, fmt->fmt.pix.height);
 		return -EINVAL;
 	}
 
 	/* Use the default frame interval. */
 	interval = frame->dwDefaultFrameInterval;
-	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-		  "Using default frame interval %u.%u us (%u.%u fps).\n",
-		  interval / 10, interval % 10, 10000000 / interval,
-		 (100000000 / interval) % 10);
+	uvc_dbg(stream->dev, FORMAT,
+		"Using default frame interval %u.%u us (%u.%u fps)\n",
+		interval / 10, interval % 10, 10000000 / interval,
+		(100000000 / interval) % 10);
 
 	/* Set the format index, frame index and frame interval. */
 	memset(probe, 0, sizeof(*probe));
@@ -262,9 +259,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (i == stream->nformats) {
-		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-			  "Unknown bFormatIndex %u\n",
-			  probe->bFormatIndex);
+		uvc_dbg(stream->dev, FORMAT, "Unknown bFormatIndex %u\n",
+			probe->bFormatIndex);
 		return -EINVAL;
 	}
 
@@ -276,9 +272,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
 	}
 
 	if (i == format->nframes) {
-		uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-			  "Unknown bFrameIndex %u\n",
-			  probe->bFrameIndex);
+		uvc_dbg(stream->dev, FORMAT, "Unknown bFrameIndex %u\n",
+			probe->bFrameIndex);
 		return -EINVAL;
 	}
 
@@ -422,9 +417,8 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
 
 	interval = uvc_fraction_to_interval(timeperframe.numerator,
 		timeperframe.denominator);
-	uvc_trace(stream->dev, UVC_TRACE_FORMAT,
-		  "Setting frame interval to %u/%u (%u).\n",
-		  timeperframe.numerator, timeperframe.denominator, interval);
+	uvc_dbg(stream->dev, FORMAT, "Setting frame interval to %u/%u (%u)\n",
+		timeperframe.numerator, timeperframe.denominator, interval);
 
 	mutex_lock(&stream->mutex);
 
@@ -553,7 +547,7 @@ static int uvc_v4l2_open(struct file *file)
 	int ret = 0;
 
 	stream = video_drvdata(file);
-	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
+	uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
 
 	ret = usb_autopm_get_interface(stream->dev->intf);
 	if (ret < 0)
@@ -595,7 +589,7 @@ static int uvc_v4l2_release(struct file *file)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
+	uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
 
 	/* Only free resources if this is a privileged handle. */
 	if (uvc_has_privileges(handle))
@@ -1471,8 +1465,7 @@ static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(stream->dev, UVC_TRACE_CALLS,
-		  "uvc_v4l2_read: not implemented.\n");
+	uvc_dbg(stream->dev, CALLS, "%s: not implemented\n", __func__);
 	return -EINVAL;
 }
 
@@ -1481,7 +1474,7 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
+	uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
 
 	return uvc_queue_mmap(&stream->queue, vma);
 }
@@ -1491,7 +1484,7 @@ static __poll_t uvc_v4l2_poll(struct file *file, poll_table *wait)
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
+	uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
 
 	return uvc_queue_poll(&stream->queue, file, wait);
 }
@@ -1504,7 +1497,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
 	struct uvc_fh *handle = file->private_data;
 	struct uvc_streaming *stream = handle->stream;
 
-	uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
+	uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
 
 	return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
 }
diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
index e44fcb645516..7189624e1ec7 100644
--- a/drivers/media/usb/uvc/uvc_video.c
+++ b/drivers/media/usb/uvc/uvc_video.c
@@ -95,7 +95,7 @@ int uvc_query_ctrl(struct uvc_device *dev, u8 query, u8 unit,
 	if (ret != 1)
 		return ret < 0 ? ret : -EPIPE;
 
-	uvc_trace(dev, UVC_TRACE_CONTROL, "Control error %u\n", error);
+	uvc_dbg(dev, CONTROL, "Control error %u\n", error);
 
 	switch (error) {
 	case 0:
@@ -705,12 +705,12 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
 
 	sof = y;
 
-	uvc_trace(stream->dev, UVC_TRACE_CLOCK,
-		  "%s: PTS %u y %llu.%06llu SOF %u.%06llu (x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
-		  stream->dev->name, buf->pts,
-		  y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
-		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
-		  x1, x2, y1, y2, clock->sof_offset);
+	uvc_dbg(stream->dev, CLOCK,
+		"%s: PTS %u y %llu.%06llu SOF %u.%06llu (x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
+		stream->dev->name, buf->pts,
+		y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
+		sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
+		x1, x2, y1, y2, clock->sof_offset);
 
 	/* Second step, SOF to host clock conversion. */
 	x1 = (uvc_video_clock_host_sof(first) + 2048) << 16;
@@ -740,13 +740,13 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
 
 	timestamp = ktime_to_ns(first->host_time) + y - y1;
 
-	uvc_trace(stream->dev, UVC_TRACE_CLOCK,
-		  "%s: SOF %u.%06llu y %llu ts %llu buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
-		  stream->dev->name,
-		  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
-		  y, timestamp, vbuf->vb2_buf.timestamp,
-		  x1, first->host_sof, first->dev_sof,
-		  x2, last->host_sof, last->dev_sof, y1, y2);
+	uvc_dbg(stream->dev, CLOCK,
+		"%s: SOF %u.%06llu y %llu ts %llu buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
+		stream->dev->name,
+		sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
+		y, timestamp, vbuf->vb2_buf.timestamp,
+		x1, first->host_sof, first->dev_sof,
+		x2, last->host_sof, last->dev_sof, y1, y2);
 
 	/* Update the V4L2 buffer. */
 	vbuf->vb2_buf.timestamp = timestamp;
@@ -875,15 +875,15 @@ static void uvc_video_stats_update(struct uvc_streaming *stream)
 {
 	struct uvc_stats_frame *frame = &stream->stats.frame;
 
-	uvc_trace(stream->dev, UVC_TRACE_STATS,
-		  "frame %u stats: %u/%u/%u packets, %u/%u/%u pts (%searly %sinitial), %u/%u scr, last pts/stc/sof %u/%u/%u\n",
-		  stream->sequence, frame->first_data,
-		  frame->nb_packets - frame->nb_empty, frame->nb_packets,
-		  frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
-		  frame->has_early_pts ? "" : "!",
-		  frame->has_initial_pts ? "" : "!",
-		  frame->nb_scr_diffs, frame->nb_scr,
-		  frame->pts, frame->scr_stc, frame->scr_sof);
+	uvc_dbg(stream->dev, STATS,
+		"frame %u stats: %u/%u/%u packets, %u/%u/%u pts (%searly %sinitial), %u/%u scr, last pts/stc/sof %u/%u/%u\n",
+		stream->sequence, frame->first_data,
+		frame->nb_packets - frame->nb_empty, frame->nb_packets,
+		frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
+		frame->has_early_pts ? "" : "!",
+		frame->has_initial_pts ? "" : "!",
+		frame->nb_scr_diffs, frame->nb_scr,
+		frame->pts, frame->scr_stc, frame->scr_sof);
 
 	stream->stats.stream.nb_frames++;
 	stream->stats.stream.nb_packets += stream->stats.frame.nb_packets;
@@ -1038,8 +1038,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 
 	/* Mark the buffer as bad if the error bit is set. */
 	if (data[1] & UVC_STREAM_ERR) {
-		uvc_trace(stream->dev, UVC_TRACE_FRAME,
-			  "Marking buffer as bad (error bit set).\n");
+		uvc_dbg(stream->dev, FRAME,
+			"Marking buffer as bad (error bit set)\n");
 		buf->error = 1;
 	}
 
@@ -1053,8 +1053,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 	 */
 	if (buf->state != UVC_BUF_STATE_ACTIVE) {
 		if (fid == stream->last_fid) {
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "Dropping payload (out of sync).\n");
+			uvc_dbg(stream->dev, FRAME,
+				"Dropping payload (out of sync)\n");
 			if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
 			    (data[1] & UVC_STREAM_EOF))
 				stream->last_fid ^= UVC_STREAM_FID;
@@ -1085,8 +1085,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 	 * previous payload had the EOF bit set.
 	 */
 	if (fid != stream->last_fid && buf->bytesused != 0) {
-		uvc_trace(stream->dev, UVC_TRACE_FRAME,
-			  "Frame complete (FID bit toggled).\n");
+		uvc_dbg(stream->dev, FRAME,
+			"Frame complete (FID bit toggled)\n");
 		buf->state = UVC_BUF_STATE_READY;
 		return -EAGAIN;
 	}
@@ -1147,8 +1147,8 @@ static void uvc_video_decode_data(struct uvc_urb *uvc_urb,
 
 	/* Complete the current frame if the buffer size was exceeded. */
 	if (len > maxlen) {
-		uvc_trace(uvc_urb->stream->dev, UVC_TRACE_FRAME,
-			  "Frame complete (overflow).\n");
+		uvc_dbg(uvc_urb->stream->dev, FRAME,
+			"Frame complete (overflow)\n");
 		buf->error = 1;
 		buf->state = UVC_BUF_STATE_READY;
 	}
@@ -1161,11 +1161,9 @@ static void uvc_video_decode_end(struct uvc_streaming *stream,
 {
 	/* Mark the buffer as done if the EOF marker is set. */
 	if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
-		uvc_trace(stream->dev, UVC_TRACE_FRAME,
-			  "Frame complete (EOF found).\n");
+		uvc_dbg(stream->dev, FRAME, "Frame complete (EOF found)\n");
 		if (data[0] == len)
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "EOF in empty payload.\n");
+			uvc_dbg(stream->dev, FRAME, "EOF in empty payload\n");
 		buf->state = UVC_BUF_STATE_READY;
 		if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
 			stream->last_fid ^= UVC_STREAM_FID;
@@ -1281,13 +1279,13 @@ static void uvc_video_decode_meta(struct uvc_streaming *stream,
 	memcpy(&meta->length, mem, length);
 	meta_buf->bytesused += length + sizeof(meta->ns) + sizeof(meta->sof);
 
-	uvc_trace(stream->dev, UVC_TRACE_FRAME,
-		  "%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n",
-		  __func__, ktime_to_ns(time), meta->sof, meta->length,
-		  meta->flags,
-		  has_pts ? *(u32 *)meta->buf : 0,
-		  has_scr ? *(u32 *)scr : 0,
-		  has_scr ? *(u32 *)(scr + 4) & 0x7ff : 0);
+	uvc_dbg(stream->dev, FRAME,
+		"%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n",
+		__func__, ktime_to_ns(time), meta->sof, meta->length,
+		meta->flags,
+		has_pts ? *(u32 *)meta->buf : 0,
+		has_scr ? *(u32 *)scr : 0,
+		has_scr ? *(u32 *)(scr + 4) & 0x7ff : 0);
 }
 
 /* ------------------------------------------------------------------------
@@ -1341,9 +1339,9 @@ static void uvc_video_decode_isoc(struct uvc_urb *uvc_urb,
 
 	for (i = 0; i < urb->number_of_packets; ++i) {
 		if (urb->iso_frame_desc[i].status < 0) {
-			uvc_trace(stream->dev, UVC_TRACE_FRAME,
-				  "USB isochronous frame lost (%d).\n",
-				  urb->iso_frame_desc[i].status);
+			uvc_dbg(stream->dev, FRAME,
+				"USB isochronous frame lost (%d)\n",
+				urb->iso_frame_desc[i].status);
 			/* Mark the buffer as faulty. */
 			if (buf != NULL)
 				buf->error = 1;
@@ -1631,16 +1629,16 @@ static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
 		}
 
 		if (i == UVC_URBS) {
-			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-				  "Allocated %u URB buffers of %ux%u bytes each.\n",
-				  UVC_URBS, npackets, psize);
+			uvc_dbg(stream->dev, VIDEO,
+				"Allocated %u URB buffers of %ux%u bytes each\n",
+				UVC_URBS, npackets, psize);
 			return npackets;
 		}
 	}
 
-	uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-		  "Failed to allocate URB buffers (%u bytes per packet).\n",
-		  psize);
+	uvc_dbg(stream->dev, VIDEO,
+		"Failed to allocate URB buffers (%u bytes per packet)\n",
+		psize);
 	return 0;
 }
 
@@ -1839,13 +1837,13 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
 		bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
 
 		if (bandwidth == 0) {
-			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-				  "Device requested null bandwidth, defaulting to lowest.\n");
+			uvc_dbg(stream->dev, VIDEO,
+				"Device requested null bandwidth, defaulting to lowest\n");
 			bandwidth = 1;
 		} else {
-			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-				  "Device requested %u B/frame bandwidth.\n",
-				  bandwidth);
+			uvc_dbg(stream->dev, VIDEO,
+				"Device requested %u B/frame bandwidth\n",
+				bandwidth);
 		}
 
 		for (i = 0; i < intf->num_altsetting; ++i) {
@@ -1868,14 +1866,14 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
 		}
 
 		if (best_ep == NULL) {
-			uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-				  "No fast enough alt setting for requested bandwidth.\n");
+			uvc_dbg(stream->dev, VIDEO,
+				"No fast enough alt setting for requested bandwidth\n");
 			return -EIO;
 		}
 
-		uvc_trace(stream->dev, UVC_TRACE_VIDEO,
-			  "Selecting alternate setting %u (%u B/frame bandwidth).\n",
-			  altsetting, best_psize);
+		uvc_dbg(stream->dev, VIDEO,
+			"Selecting alternate setting %u (%u B/frame bandwidth)\n",
+			altsetting, best_psize);
 
 		ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
 		if (ret < 0)
diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
index 63f7e88c5713..1ca16c95ba25 100644
--- a/drivers/media/usb/uvc/uvcvideo.h
+++ b/drivers/media/usb/uvc/uvcvideo.h
@@ -731,18 +731,18 @@ struct uvc_driver {
  * Debugging, printing and logging
  */
 
-#define UVC_TRACE_PROBE		(1 << 0)
-#define UVC_TRACE_DESCR		(1 << 1)
-#define UVC_TRACE_CONTROL	(1 << 2)
-#define UVC_TRACE_FORMAT	(1 << 3)
-#define UVC_TRACE_CAPTURE	(1 << 4)
-#define UVC_TRACE_CALLS		(1 << 5)
-#define UVC_TRACE_FRAME		(1 << 7)
-#define UVC_TRACE_SUSPEND	(1 << 8)
-#define UVC_TRACE_STATUS	(1 << 9)
-#define UVC_TRACE_VIDEO		(1 << 10)
-#define UVC_TRACE_STATS		(1 << 11)
-#define UVC_TRACE_CLOCK		(1 << 12)
+#define UVC_DBG_PROBE		(1 << 0)
+#define UVC_DBG_DESCR		(1 << 1)
+#define UVC_DBG_CONTROL		(1 << 2)
+#define UVC_DBG_FORMAT		(1 << 3)
+#define UVC_DBG_CAPTURE		(1 << 4)
+#define UVC_DBG_CALLS		(1 << 5)
+#define UVC_DBG_FRAME		(1 << 7)
+#define UVC_DBG_SUSPEND		(1 << 8)
+#define UVC_DBG_STATUS		(1 << 9)
+#define UVC_DBG_VIDEO		(1 << 10)
+#define UVC_DBG_STATS		(1 << 11)
+#define UVC_DBG_CLOCK		(1 << 12)
 
 #define UVC_WARN_MINMAX		0
 #define UVC_WARN_PROBE_DEF	1
@@ -750,20 +750,20 @@ struct uvc_driver {
 
 extern unsigned int uvc_clock_param;
 extern unsigned int uvc_no_drop_param;
-extern unsigned int uvc_trace_param;
+extern unsigned int uvc_dbg_param;
 extern unsigned int uvc_timeout_param;
 extern unsigned int uvc_hw_timestamps_param;
 
-#define uvc_trace(_dev, flag, fmt, ...)					\
+#define uvc_dbg(_dev, flag, fmt, ...)					\
 do {									\
-	if (uvc_trace_param & flag)					\
+	if (uvc_dbg_param & UVC_DBG_##flag)				\
 		dev_printk(KERN_DEBUG, &(_dev)->udev->dev, fmt,		\
 			   ##__VA_ARGS__);				\
 } while (0)
 
-#define uvc_trace_cont(flag, fmt, ...)					\
+#define uvc_dbg_cont(flag, fmt, ...)					\
 do {									\
-	if (uvc_trace_param & flag)					\
+	if (uvc_dbg_param & UVC_DBG_##flag)				\
 		pr_cont(fmt, ##__VA_ARGS__);				\
 } while (0)
 

Re: [PATCH v6 11/11] media: uvcvideo: use dev_printk() for uvc_trace()

[Ricardo Ribalda]

Hi Joe

On Wed, Dec 23, 2020 at 12:30 PM Joe Perches <joe@perches.com> wrote:
>
> Perhaps this on top.
>
> trace isn't a good name as it's not a trace mechanism, it is a
> typical debug mechanism.
>
> Rename uvc_trace/uvc_trace_cont macros to uvc_dbg/uvc_dbg_cont.
> Rename uvc_trace_param to uvc_dbg_param
> Rename UVC_TRACE_<FOO> defines to UVC_DBG_<FOO>
> Use ## concatenation in uvc_dbg macros to avoid overly long and
> repetitive UVC_DBG uses
> ---
I have added your patch to

https://patchwork.linuxtv.org/project/linux-media/patch/20201223133528.55014-12-ribalda@chromium.org/

Hope you don't mind.

Cheers!

>  drivers/media/usb/uvc/uvc_ctrl.c   |  81 +++++----
>  drivers/media/usb/uvc/uvc_driver.c | 343 ++++++++++++++++++-------------------
>  drivers/media/usb/uvc/uvc_isight.c |  17 +-
>  drivers/media/usb/uvc/uvc_queue.c  |   4 +-
>  drivers/media/usb/uvc/uvc_status.c |  29 ++--
>  drivers/media/usb/uvc/uvc_v4l2.c   |  55 +++---
>  drivers/media/usb/uvc/uvc_video.c  | 120 +++++++------
>  drivers/media/usb/uvc/uvcvideo.h   |  34 ++--
>  8 files changed, 331 insertions(+), 352 deletions(-)
>
> diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
> index bf448c213c53..7b70877b2483 100644
> --- a/drivers/media/usb/uvc/uvc_ctrl.c
> +++ b/drivers/media/usb/uvc/uvc_ctrl.c
> @@ -906,8 +906,8 @@ static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
>         }
>
>         if (ctrl == NULL && !next)
> -               uvc_trace(chain->dev, UVC_TRACE_CONTROL,
> -                         "Control 0x%08x not found.\n", v4l2_id);
> +               uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",
> +                       v4l2_id);
>
>         return ctrl;
>  }
> @@ -1820,9 +1820,9 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
>         ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id, dev->intfnum,
>                              info->selector, data, 2);
>         if (ret < 0) {
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "GET_LEN failed on control %pUl/%u (%d).\n",
> -                         info->entity, info->selector, ret);
> +               uvc_dbg(dev, CONTROL,
> +                       "GET_LEN failed on control %pUl/%u (%d)\n",
> +                       info->entity, info->selector, ret);
>                 goto done;
>         }
>
> @@ -1833,20 +1833,20 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
>
>         ret = uvc_ctrl_get_flags(dev, ctrl, info);
>         if (ret < 0) {
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "Failed to get flags for control %pUl/%u (%d).\n",
> -                         info->entity, info->selector, ret);
> +               uvc_dbg(dev, CONTROL,
> +                       "Failed to get flags for control %pUl/%u (%d)\n",
> +                       info->entity, info->selector, ret);
>                 goto done;
>         }
>
>         uvc_ctrl_fixup_xu_info(dev, ctrl, info);
>
> -       uvc_trace(dev, UVC_TRACE_CONTROL,
> -                 "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }.\n",
> -                 info->entity, info->selector, info->size,
> -                 (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
> -                 (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
> -                 (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
> +       uvc_dbg(dev, CONTROL,
> +               "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }\n",
> +               info->entity, info->selector, info->size,
> +               (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
> +               (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
> +               (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
>
>  done:
>         kfree(data);
> @@ -1871,10 +1871,10 @@ static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
>
>         ret = uvc_ctrl_add_info(dev, ctrl, &info);
>         if (ret < 0)
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "Failed to initialize control %pUl/%u on device %s entity %u\n",
> -                         info.entity, info.selector, dev->udev->devpath,
> -                         ctrl->entity->id);
> +               uvc_dbg(dev, CONTROL,
> +                       "Failed to initialize control %pUl/%u on device %s entity %u\n",
> +                       info.entity, info.selector, dev->udev->devpath,
> +                       ctrl->entity->id);
>
>         return ret;
>  }
> @@ -1902,8 +1902,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
>         }
>
>         if (!found) {
> -               uvc_trace(chain->dev, UVC_TRACE_CONTROL,
> -                         "Extension unit %u not found.\n", xqry->unit);
> +               uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",
> +                       xqry->unit);
>                 return -ENOENT;
>         }
>
> @@ -1918,9 +1918,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
>         }
>
>         if (!found) {
> -               uvc_trace(chain->dev, UVC_TRACE_CONTROL,
> -                         "Control %pUl/%u not found.\n", entity->guid,
> -                         xqry->selector);
> +               uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",
> +                       entity->guid, xqry->selector);
>                 return -ENOENT;
>         }
>
> @@ -2068,10 +2067,9 @@ static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
>
>         ctrl->initialized = 1;
>
> -       uvc_trace(dev, UVC_TRACE_CONTROL,
> -                 "Added control %pUl/%u to device %s entity %u\n",
> -                 ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
> -                 ctrl->entity->id);
> +       uvc_dbg(dev, CONTROL, "Added control %pUl/%u to device %s entity %u\n",
> +               ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
> +               ctrl->entity->id);
>
>         return 0;
>  }
> @@ -2108,9 +2106,8 @@ static int __uvc_ctrl_add_mapping(struct uvc_device *dev,
>                 map->set = uvc_set_le_value;
>
>         list_add_tail(&map->list, &ctrl->info.mappings);
> -       uvc_trace(dev, UVC_TRACE_CONTROL,
> -                 "Adding mapping '%s' to control %pUl/%u.\n",
> -                 map->name, ctrl->info.entity, ctrl->info.selector);
> +       uvc_dbg(dev, CONTROL, "Adding mapping '%s' to control %pUl/%u\n",
> +               map->name, ctrl->info.entity, ctrl->info.selector);
>
>         return 0;
>  }
> @@ -2126,9 +2123,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
>         int ret;
>
>         if (mapping->id & ~V4L2_CTRL_ID_MASK) {
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "Can't add mapping '%s', control id 0x%08x is invalid.\n",
> -                         mapping->name, mapping->id);
> +               uvc_dbg(dev, CONTROL,
> +                       "Can't add mapping '%s', control id 0x%08x is invalid\n",
> +                       mapping->name, mapping->id);
>                 return -EINVAL;
>         }
>
> @@ -2173,9 +2170,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
>
>         list_for_each_entry(map, &ctrl->info.mappings, list) {
>                 if (mapping->id == map->id) {
> -                       uvc_trace(dev, UVC_TRACE_CONTROL,
> -                                 "Can't add mapping '%s', control id 0x%08x already exists.\n",
> -                                 mapping->name, mapping->id);
> +                       uvc_dbg(dev, CONTROL,
> +                               "Can't add mapping '%s', control id 0x%08x already exists\n",
> +                               mapping->name, mapping->id);
>                         ret = -EEXIST;
>                         goto done;
>                 }
> @@ -2184,9 +2181,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
>         /* Prevent excess memory consumption */
>         if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
>                 atomic_dec(&dev->nmappings);
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "Can't add mapping '%s', maximum mappings count (%u) exceeded.\n",
> -                         mapping->name, UVC_MAX_CONTROL_MAPPINGS);
> +               uvc_dbg(dev, CONTROL,
> +                       "Can't add mapping '%s', maximum mappings count (%u) exceeded\n",
> +                       mapping->name, UVC_MAX_CONTROL_MAPPINGS);
>                 ret = -ENOMEM;
>                 goto done;
>         }
> @@ -2255,9 +2252,9 @@ static void uvc_ctrl_prune_entity(struct uvc_device *dev,
>                     !uvc_test_bit(controls, blacklist[i].index))
>                         continue;
>
> -               uvc_trace(dev, UVC_TRACE_CONTROL,
> -                         "%u/%u control is black listed, removing it.\n",
> -                         entity->id, blacklist[i].index);
> +               uvc_dbg(dev, CONTROL,
> +                       "%u/%u control is black listed, removing it\n",
> +                       entity->id, blacklist[i].index);
>
>                 uvc_clear_bit(controls, blacklist[i].index);
>         }
> diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
> index 1f72bda6036e..2dbed5c3831a 100644
> --- a/drivers/media/usb/uvc/uvc_driver.c
> +++ b/drivers/media/usb/uvc/uvc_driver.c
> @@ -33,7 +33,7 @@ unsigned int uvc_clock_param = CLOCK_MONOTONIC;
>  unsigned int uvc_hw_timestamps_param;
>  unsigned int uvc_no_drop_param;
>  static unsigned int uvc_quirks_param = -1;
> -unsigned int uvc_trace_param;
> +unsigned int uvc_dbg_param;
>  unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
>
>  /* ------------------------------------------------------------------------
> @@ -521,10 +521,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>         case UVC_VS_FORMAT_FRAME_BASED:
>                 n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
>                 if (buflen < n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d FORMAT error\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d FORMAT error\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -585,10 +585,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>
>         case UVC_VS_FORMAT_MJPEG:
>                 if (buflen < 11) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d FORMAT error\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d FORMAT error\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -601,10 +601,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>
>         case UVC_VS_FORMAT_DV:
>                 if (buflen < 9) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d FORMAT error\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d FORMAT error\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -619,10 +619,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>                         strscpy(format->name, "HD-DV", sizeof(format->name));
>                         break;
>                 default:
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d: unknown DV format %u\n",
> -                                 dev->udev->devnum,
> -                              alts->desc.bInterfaceNumber, buffer[8]);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d: unknown DV format %u\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber, buffer[8]);
>                         return -EINVAL;
>                 }
>
> @@ -648,14 +648,14 @@ static int uvc_parse_format(struct uvc_device *dev,
>         case UVC_VS_FORMAT_STREAM_BASED:
>                 /* Not supported yet. */
>         default:
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d videostreaming interface %d unsupported format %u\n",
> -                         dev->udev->devnum, alts->desc.bInterfaceNumber,
> -                         buffer[2]);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d videostreaming interface %d unsupported format %u\n",
> +                       dev->udev->devnum, alts->desc.bInterfaceNumber,
> +                       buffer[2]);
>                 return -EINVAL;
>         }
>
> -       uvc_trace(dev, UVC_TRACE_DESCR, "Found format %s.\n", format->name);
> +       uvc_dbg(dev, DESCR, "Found format %s\n", format->name);
>
>         buflen -= buffer[0];
>         buffer += buffer[0];
> @@ -674,10 +674,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>                 n = n ? n : 3;
>
>                 if (buflen < 26 + 4*n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d FRAME error\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d FRAME error\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -739,10 +739,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>                                 frame->dwDefaultFrameInterval;
>                 }
>
> -               uvc_trace(dev, UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n",
> -                         frame->wWidth, frame->wHeight,
> -                         10000000 / frame->dwDefaultFrameInterval,
> -                         (100000000 / frame->dwDefaultFrameInterval) % 10);
> +               uvc_dbg(dev, DESCR, "- %ux%u (%u.%u fps)\n",
> +                       frame->wWidth, frame->wHeight,
> +                       10000000 / frame->dwDefaultFrameInterval,
> +                       (100000000 / frame->dwDefaultFrameInterval) % 10);
>
>                 format->nframes++;
>                 buflen -= buffer[0];
> @@ -758,10 +758,10 @@ static int uvc_parse_format(struct uvc_device *dev,
>         if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
>             buffer[2] == UVC_VS_COLORFORMAT) {
>                 if (buflen < 6) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d COLORFORMAT error\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d COLORFORMAT error\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -793,18 +793,18 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>
>         if (intf->cur_altsetting->desc.bInterfaceSubClass
>                 != UVC_SC_VIDEOSTREAMING) {
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d interface %d isn't a video streaming interface\n",
> -                         dev->udev->devnum,
> -                         intf->altsetting[0].desc.bInterfaceNumber);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d interface %d isn't a video streaming interface\n",
> +                       dev->udev->devnum,
> +                       intf->altsetting[0].desc.bInterfaceNumber);
>                 return -EINVAL;
>         }
>
>         if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d interface %d is already claimed\n",
> -                         dev->udev->devnum,
> -                         intf->altsetting[0].desc.bInterfaceNumber);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d interface %d is already claimed\n",
> +                       dev->udev->devnum,
> +                       intf->altsetting[0].desc.bInterfaceNumber);
>                 return -EINVAL;
>         }
>
> @@ -826,9 +826,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>
>                         if (ep->extralen > 2 &&
>                             ep->extra[1] == USB_DT_CS_INTERFACE) {
> -                               uvc_trace(dev, UVC_TRACE_DESCR,
> -                                         "trying extra data from endpoint %u.\n",
> -                                         i);
> +                               uvc_dbg(dev, DESCR,
> +                                       "trying extra data from endpoint %u\n",
> +                                       i);
>                                 buffer = alts->endpoint[i].extra;
>                                 buflen = alts->endpoint[i].extralen;
>                                 break;
> @@ -843,8 +843,8 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>         }
>
>         if (buflen <= 2) {
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "no class-specific streaming interface descriptors found.\n");
> +               uvc_dbg(dev, DESCR,
> +                       "no class-specific streaming interface descriptors found\n");
>                 goto error;
>         }
>
> @@ -861,9 +861,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>                 break;
>
>         default:
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d videostreaming interface %d HEADER descriptor not found.\n",
> -                         dev->udev->devnum, alts->desc.bInterfaceNumber);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d videostreaming interface %d HEADER descriptor not found\n",
> +                       dev->udev->devnum, alts->desc.bInterfaceNumber);
>                 goto error;
>         }
>
> @@ -871,9 +871,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>         n = buflen >= size ? buffer[size-1] : 0;
>
>         if (buflen < size + p*n) {
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d videostreaming interface %d HEADER descriptor is invalid.\n",
> -                         dev->udev->devnum, alts->desc.bInterfaceNumber);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d videostreaming interface %d HEADER descriptor is invalid\n",
> +                       dev->udev->devnum, alts->desc.bInterfaceNumber);
>                 goto error;
>         }
>
> @@ -923,10 +923,10 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>
>                 case UVC_VS_FORMAT_MPEG2TS:
>                 case UVC_VS_FORMAT_STREAM_BASED:
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videostreaming interface %d FORMAT %u is not supported.\n",
> -                                 dev->udev->devnum,
> -                                 alts->desc.bInterfaceNumber, _buffer[2]);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videostreaming interface %d FORMAT %u is not supported\n",
> +                               dev->udev->devnum,
> +                               alts->desc.bInterfaceNumber, _buffer[2]);
>                         break;
>
>                 case UVC_VS_FRAME_UNCOMPRESSED:
> @@ -948,9 +948,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>         }
>
>         if (nformats == 0) {
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d videostreaming interface %d has no supported formats defined.\n",
> -                         dev->udev->devnum, alts->desc.bInterfaceNumber);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d videostreaming interface %d has no supported formats defined\n",
> +                       dev->udev->devnum, alts->desc.bInterfaceNumber);
>                 goto error;
>         }
>
> @@ -997,10 +997,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
>         }
>
>         if (buflen)
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage.\n",
> -                         dev->udev->devnum, alts->desc.bInterfaceNumber,
> -                         buflen);
> +               uvc_dbg(dev, DESCR,
> +                       "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage\n",
> +                       dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
>
>         /* Parse the alternate settings to find the maximum bandwidth. */
>         for (i = 0; i < intf->num_altsetting; ++i) {
> @@ -1133,9 +1132,9 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
>                 n = buflen >= 25 + p ? buffer[22+p] : 0;
>
>                 if (buflen < 25 + p + 2*n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d EXTENSION_UNIT error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d EXTENSION_UNIT error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         break;
>                 }
>
> @@ -1182,9 +1181,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 n = buflen >= 12 ? buffer[11] : 0;
>
>                 if (buflen < 12 + n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d HEADER error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d HEADER error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1195,9 +1194,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 for (i = 0; i < n; ++i) {
>                         intf = usb_ifnum_to_if(udev, buffer[12+i]);
>                         if (intf == NULL) {
> -                               uvc_trace(dev, UVC_TRACE_DESCR,
> -                                         "device %d interface %d doesn't exists\n",
> -                                         udev->devnum, i);
> +                               uvc_dbg(dev, DESCR,
> +                                       "device %d interface %d doesn't exists\n",
> +                                       udev->devnum, i);
>                                 continue;
>                         }
>
> @@ -1207,9 +1206,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>
>         case UVC_VC_INPUT_TERMINAL:
>                 if (buflen < 8) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d INPUT_TERMINAL error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d INPUT_TERMINAL error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1226,10 +1225,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                  */
>                 type = get_unaligned_le16(&buffer[4]);
>                 if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber,
> -                                 buffer[3], type);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber,
> +                               buffer[3], type);
>                         return 0;
>                 }
>
> @@ -1248,9 +1247,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 }
>
>                 if (buflen < len + n + p) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d INPUT_TERMINAL error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d INPUT_TERMINAL error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1295,9 +1294,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>
>         case UVC_VC_OUTPUT_TERMINAL:
>                 if (buflen < 9) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1306,10 +1305,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                  */
>                 type = get_unaligned_le16(&buffer[4]);
>                 if ((type & 0xff00) == 0) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber,
> -                                 buffer[3], type);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber,
> +                               buffer[3], type);
>                         return 0;
>                 }
>
> @@ -1333,9 +1332,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 p = buflen >= 5 ? buffer[4] : 0;
>
>                 if (buflen < 5 || buflen < 6 + p) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d SELECTOR_UNIT error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d SELECTOR_UNIT error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1359,9 +1358,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 p = dev->uvc_version >= 0x0110 ? 10 : 9;
>
>                 if (buflen < p + n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d PROCESSING_UNIT error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d PROCESSING_UNIT error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1392,9 +1391,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 n = buflen >= 24 + p ? buffer[22+p] : 0;
>
>                 if (buflen < 24 + p + n) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "device %d videocontrol interface %d EXTENSION_UNIT error\n",
> -                                 udev->devnum, alts->desc.bInterfaceNumber);
> +                       uvc_dbg(dev, DESCR,
> +                               "device %d videocontrol interface %d EXTENSION_UNIT error\n",
> +                               udev->devnum, alts->desc.bInterfaceNumber);
>                         return -EINVAL;
>                 }
>
> @@ -1419,9 +1418,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
>                 break;
>
>         default:
> -               uvc_trace(dev, UVC_TRACE_DESCR,
> -                         "Found an unknown CS_INTERFACE descriptor (%u)\n",
> -                         buffer[2]);
> +               uvc_dbg(dev, DESCR,
> +                       "Found an unknown CS_INTERFACE descriptor (%u)\n",
> +                       buffer[2]);
>                 break;
>         }
>
> @@ -1466,9 +1465,9 @@ static int uvc_parse_control(struct uvc_device *dev)
>                 if (usb_endpoint_is_int_in(desc) &&
>                     le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
>                     desc->bInterval != 0) {
> -                       uvc_trace(dev, UVC_TRACE_DESCR,
> -                                 "Found a Status endpoint (addr %02x).\n",
> -                                 desc->bEndpointAddress);
> +                       uvc_dbg(dev, DESCR,
> +                               "Found a Status endpoint (addr %02x)\n",
> +                               desc->bEndpointAddress);
>                         dev->int_ep = ep;
>                 }
>         }
> @@ -1652,23 +1651,23 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
>  {
>         switch (UVC_ENTITY_TYPE(entity)) {
>         case UVC_VC_EXTENSION_UNIT:
> -               uvc_trace_cont(UVC_TRACE_PROBE, " <- XU %d", entity->id);
> +               uvc_dbg_cont(PROBE, " <- XU %d", entity->id);
>
>                 if (entity->bNrInPins != 1) {
> -                       uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                 "Extension unit %d has more than 1 input pin.\n",
> -                                 entity->id);
> +                       uvc_dbg(chain->dev, DESCR,
> +                               "Extension unit %d has more than 1 input pin\n",
> +                               entity->id);
>                         return -1;
>                 }
>
>                 break;
>
>         case UVC_VC_PROCESSING_UNIT:
> -               uvc_trace_cont(UVC_TRACE_PROBE, " <- PU %d", entity->id);
> +               uvc_dbg_cont(PROBE, " <- PU %d", entity->id);
>
>                 if (chain->processing != NULL) {
> -                       uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                 "Found multiple Processing Units in chain.\n");
> +                       uvc_dbg(chain->dev, DESCR,
> +                               "Found multiple Processing Units in chain\n");
>                         return -1;
>                 }
>
> @@ -1676,15 +1675,15 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
>                 break;
>
>         case UVC_VC_SELECTOR_UNIT:
> -               uvc_trace_cont(UVC_TRACE_PROBE, " <- SU %d", entity->id);
> +               uvc_dbg_cont(PROBE, " <- SU %d", entity->id);
>
>                 /* Single-input selector units are ignored. */
>                 if (entity->bNrInPins == 1)
>                         break;
>
>                 if (chain->selector != NULL) {
> -                       uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                 "Found multiple Selector Units in chain.\n");
> +                       uvc_dbg(chain->dev, DESCR,
> +                               "Found multiple Selector Units in chain\n");
>                         return -1;
>                 }
>
> @@ -1694,29 +1693,29 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
>         case UVC_ITT_VENDOR_SPECIFIC:
>         case UVC_ITT_CAMERA:
>         case UVC_ITT_MEDIA_TRANSPORT_INPUT:
> -               uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
> +               uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id);
>
>                 break;
>
>         case UVC_OTT_VENDOR_SPECIFIC:
>         case UVC_OTT_DISPLAY:
>         case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
> -               uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
> +               uvc_dbg_cont(PROBE, " OT %d", entity->id);
>
>                 break;
>
>         case UVC_TT_STREAMING:
>                 if (UVC_ENTITY_IS_ITERM(entity))
> -                       uvc_trace_cont(UVC_TRACE_PROBE, " <- IT %d\n", entity->id);
> +                       uvc_dbg_cont(PROBE, " <- IT %d\n", entity->id);
>                 else
> -                       uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id);
> +                       uvc_dbg_cont(PROBE, " OT %d", entity->id);
>
>                 break;
>
>         default:
> -               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                         "Unsupported entity type 0x%04x found in chain.\n",
> -                         UVC_ENTITY_TYPE(entity));
> +               uvc_dbg(chain->dev, DESCR,
> +                       "Unsupported entity type 0x%04x found in chain\n",
> +                       UVC_ENTITY_TYPE(entity));
>                 return -1;
>         }
>
> @@ -1742,26 +1741,26 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
>                 if (forward == prev)
>                         continue;
>                 if (forward->chain.next || forward->chain.prev) {
> -                       uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                 "Found reference to entity %d already in chain.\n",
> -                                 forward->id);
> +                       uvc_dbg(chain->dev, DESCR,
> +                               "Found reference to entity %d already in chain\n",
> +                               forward->id);
>                         return -EINVAL;
>                 }
>
>                 switch (UVC_ENTITY_TYPE(forward)) {
>                 case UVC_VC_EXTENSION_UNIT:
>                         if (forward->bNrInPins != 1) {
> -                               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                         "Extension unit %d has more than 1 input pin.\n",
> -                                         entity->id);
> +                               uvc_dbg(chain->dev, DESCR,
> +                                       "Extension unit %d has more than 1 input pin\n",
> +                                       entity->id);
>                                 return -EINVAL;
>                         }
>
>                         list_add_tail(&forward->chain, &chain->entities);
>                         if (!found)
> -                               uvc_trace_cont(UVC_TRACE_PROBE, " (->");
> +                               uvc_dbg_cont(PROBE, " (->");
>
> -                       uvc_trace_cont(UVC_TRACE_PROBE, " XU %d", forward->id);
> +                       uvc_dbg_cont(PROBE, " XU %d", forward->id);
>                         found = 1;
>                         break;
>
> @@ -1770,23 +1769,23 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
>                 case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
>                 case UVC_TT_STREAMING:
>                         if (UVC_ENTITY_IS_ITERM(forward)) {
> -                               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                         "Unsupported input terminal %u.\n",
> -                                         forward->id);
> +                               uvc_dbg(chain->dev, DESCR,
> +                                       "Unsupported input terminal %u\n",
> +                                       forward->id);
>                                 return -EINVAL;
>                         }
>
>                         list_add_tail(&forward->chain, &chain->entities);
>                         if (!found)
> -                               uvc_trace_cont(UVC_TRACE_PROBE, " (->");
> +                               uvc_dbg_cont(PROBE, " (->");
>
> -                       uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", forward->id);
> +                       uvc_dbg_cont(PROBE, " OT %d", forward->id);
>                         found = 1;
>                         break;
>                 }
>         }
>         if (found)
> -               uvc_trace_cont(UVC_TRACE_PROBE, ")");
> +               uvc_dbg_cont(PROBE, ")");
>
>         return 0;
>  }
> @@ -1811,33 +1810,33 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
>                         break;
>                 }
>
> -               uvc_trace_cont(UVC_TRACE_PROBE, " <- IT");
> +               uvc_dbg_cont(PROBE, " <- IT");
>
>                 chain->selector = entity;
>                 for (i = 0; i < entity->bNrInPins; ++i) {
>                         id = entity->baSourceID[i];
>                         term = uvc_entity_by_id(chain->dev, id);
>                         if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
> -                               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                         "Selector unit %d input %d isn't connected to an input terminal\n",
> -                                         entity->id, i);
> +                               uvc_dbg(chain->dev, DESCR,
> +                                       "Selector unit %d input %d isn't connected to an input terminal\n",
> +                                       entity->id, i);
>                                 return -1;
>                         }
>
>                         if (term->chain.next || term->chain.prev) {
> -                               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                         "Found reference to entity %d already in chain.\n",
> -                                         term->id);
> +                               uvc_dbg(chain->dev, DESCR,
> +                                       "Found reference to entity %d already in chain\n",
> +                                       term->id);
>                                 return -EINVAL;
>                         }
>
> -                       uvc_trace_cont(UVC_TRACE_PROBE, " %d", term->id);
> +                       uvc_dbg_cont(PROBE, " %d", term->id);
>
>                         list_add_tail(&term->chain, &chain->entities);
>                         uvc_scan_chain_forward(chain, term, entity);
>                 }
>
> -               uvc_trace_cont(UVC_TRACE_PROBE, "\n");
> +               uvc_dbg_cont(PROBE, "\n");
>
>                 id = 0;
>                 break;
> @@ -1860,8 +1859,8 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
>
>         entity = uvc_entity_by_id(chain->dev, id);
>         if (entity == NULL) {
> -               uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                         "Found reference to unknown entity %d.\n", id);
> +               uvc_dbg(chain->dev, DESCR,
> +                       "Found reference to unknown entity %d\n", id);
>                 return -EINVAL;
>         }
>
> @@ -1874,7 +1873,7 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
>  {
>         struct uvc_entity *entity, *prev;
>
> -       uvc_trace(chain->dev, UVC_TRACE_PROBE, "Scanning UVC chain:");
> +       uvc_dbg(chain->dev, PROBE, "Scanning UVC chain:");
>
>         entity = term;
>         prev = NULL;
> @@ -1882,9 +1881,9 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
>         while (entity != NULL) {
>                 /* Entity must not be part of an existing chain */
>                 if (entity->chain.next || entity->chain.prev) {
> -                       uvc_trace(chain->dev, UVC_TRACE_DESCR,
> -                                 "Found reference to entity %d already in chain.\n",
> -                                 entity->id);
> +                       uvc_dbg(chain->dev, DESCR,
> +                               "Found reference to entity %d already in chain\n",
> +                               entity->id);
>                         return -EINVAL;
>                 }
>
> @@ -2038,9 +2037,8 @@ static int uvc_scan_fallback(struct uvc_device *dev)
>
>         list_add_tail(&chain->list, &dev->chains);
>
> -       uvc_trace(dev, UVC_TRACE_PROBE,
> -                 "Found a video chain by fallback heuristic (%s).\n",
> -                 uvc_print_chain(chain));
> +       uvc_dbg(dev, PROBE, "Found a video chain by fallback heuristic (%s)\n",
> +               uvc_print_chain(chain));
>
>         return 0;
>
> @@ -2082,9 +2080,8 @@ static int uvc_scan_device(struct uvc_device *dev)
>                         continue;
>                 }
>
> -               uvc_trace(dev, UVC_TRACE_PROBE,
> -                         "Found a valid video chain (%s).\n",
> -                         uvc_print_chain(chain));
> +               uvc_dbg(dev, PROBE, "Found a valid video chain (%s)\n",
> +                       uvc_print_chain(chain));
>
>                 list_add_tail(&chain->list, &dev->chains);
>         }
> @@ -2384,12 +2381,11 @@ static int uvc_probe(struct usb_interface *intf,
>                     ? dev->info->quirks : uvc_quirks_param;
>
>         if (id->idVendor && id->idProduct)
> -               uvc_trace(dev, UVC_TRACE_PROBE,
> -                         "Probing known UVC device %s (%04x:%04x)\n",
> -                         udev->devpath, id->idVendor, id->idProduct);
> +               uvc_dbg(dev, PROBE, "Probing known UVC device %s (%04x:%04x)\n",
> +                       udev->devpath, id->idVendor, id->idProduct);
>         else
> -               uvc_trace(dev, UVC_TRACE_PROBE,
> -                         "Probing generic UVC device %s\n", udev->devpath);
> +               uvc_dbg(dev, PROBE, "Probing generic UVC device %s\n",
> +                       udev->devpath);
>
>         if (udev->product != NULL)
>                 strscpy(dev->name, udev->product, sizeof(dev->name));
> @@ -2433,14 +2429,13 @@ static int uvc_probe(struct usb_interface *intf,
>
>         /* Parse the Video Class control descriptor. */
>         if (uvc_parse_control(dev) < 0) {
> -               uvc_trace(dev, UVC_TRACE_PROBE,
> -                         "Unable to parse UVC descriptors.\n");
> +               uvc_dbg(dev, PROBE, "Unable to parse UVC descriptors\n");
>                 goto error;
>         }
>
>         /* Parse the associated GPIOs. */
>         if (uvc_gpio_parse(dev) < 0) {
> -               uvc_trace(dev, UVC_TRACE_PROBE, "Unable to parse UVC GPIOs\n");
> +               uvc_dbg(dev, PROBE, "Unable to parse UVC GPIOs\n");
>                 goto error;
>         }
>
> @@ -2495,7 +2490,7 @@ static int uvc_probe(struct usb_interface *intf,
>                          "Unable to request privacy GPIO IRQ %d. Continuing without privacy events\n",
>                          ret);
>
> -       uvc_trace(dev, UVC_TRACE_PROBE, "UVC device initialized.\n");
> +       uvc_dbg(dev, PROBE, "UVC device initialized\n");
>         usb_enable_autosuspend(udev);
>         return 0;
>
> @@ -2527,7 +2522,7 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
>         struct uvc_device *dev = usb_get_intfdata(intf);
>         struct uvc_streaming *stream;
>
> -       uvc_trace(dev, UVC_TRACE_SUSPEND, "Suspending interface %u\n",
> +       uvc_dbg(dev, SUSPEND, "Suspending interface %u\n",
>                 intf->cur_altsetting->desc.bInterfaceNumber);
>
>         /* Controls are cached on the fly so they don't need to be saved. */
> @@ -2545,8 +2540,8 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
>                         return uvc_video_suspend(stream);
>         }
>
> -       uvc_trace(dev, UVC_TRACE_SUSPEND,
> -                 "Suspend: video streaming USB interface mismatch.\n");
> +       uvc_dbg(dev, SUSPEND,
> +               "Suspend: video streaming USB interface mismatch\n");
>         return -EINVAL;
>  }
>
> @@ -2556,8 +2551,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
>         struct uvc_streaming *stream;
>         int ret = 0;
>
> -       uvc_trace(dev, UVC_TRACE_SUSPEND, "Resuming interface %u\n",
> -                 intf->cur_altsetting->desc.bInterfaceNumber);
> +       uvc_dbg(dev, SUSPEND, "Resuming interface %u\n",
> +               intf->cur_altsetting->desc.bInterfaceNumber);
>
>         if (intf->cur_altsetting->desc.bInterfaceSubClass ==
>             UVC_SC_VIDEOCONTROL) {
> @@ -2585,8 +2580,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
>                 }
>         }
>
> -       uvc_trace(dev, UVC_TRACE_SUSPEND,
> -                 "Resume: video streaming USB interface mismatch.\n");
> +       uvc_dbg(dev, SUSPEND,
> +               "Resume: video streaming USB interface mismatch\n");
>         return -EINVAL;
>  }
>
> @@ -2636,7 +2631,7 @@ module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
>  MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
>  module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
>  MODULE_PARM_DESC(quirks, "Forced device quirks");
> -module_param_named(trace, uvc_trace_param, uint, S_IRUGO|S_IWUSR);
> +module_param_named(trace, uvc_dbg_param, uint, S_IRUGO|S_IWUSR);
>  MODULE_PARM_DESC(trace, "Trace level bitmask");
>  module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
>  MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
> diff --git a/drivers/media/usb/uvc/uvc_isight.c b/drivers/media/usb/uvc/uvc_isight.c
> index 445c4d39aeff..2578d6ee4829 100644
> --- a/drivers/media/usb/uvc/uvc_isight.c
> +++ b/drivers/media/usb/uvc/uvc_isight.c
> @@ -50,16 +50,15 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
>
>         if ((len >= 14 && memcmp(&data[2], hdr, 12) == 0) ||
>             (len >= 15 && memcmp(&data[3], hdr, 12) == 0)) {
> -               uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                         "iSight header found\n");
> +               uvc_dbg(stream->dev, FRAME, "iSight header found\n");
>                 is_header = 1;
>         }
>
>         /* Synchronize to the input stream by waiting for a header packet. */
>         if (buf->state != UVC_BUF_STATE_ACTIVE) {
>                 if (!is_header) {
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "Dropping packet (out of sync).\n");
> +                       uvc_dbg(stream->dev, FRAME,
> +                               "Dropping packet (out of sync)\n");
>                         return 0;
>                 }
>
> @@ -87,8 +86,8 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
>                 buf->bytesused += nbytes;
>
>                 if (len > maxlen || buf->bytesused == buf->length) {
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "Frame complete (overflow).\n");
> +                       uvc_dbg(stream->dev, FRAME,
> +                               "Frame complete (overflow)\n");
>                         buf->state = UVC_BUF_STATE_DONE;
>                 }
>         }
> @@ -105,9 +104,9 @@ void uvc_video_decode_isight(struct uvc_urb *uvc_urb, struct uvc_buffer *buf,
>
>         for (i = 0; i < urb->number_of_packets; ++i) {
>                 if (urb->iso_frame_desc[i].status < 0) {
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "USB isochronous frame lost (%d).\n",
> -                                 urb->iso_frame_desc[i].status);
> +                       uvc_dbg(stream->dev, FRAME,
> +                               "USB isochronous frame lost (%d)\n",
> +                               urb->iso_frame_desc[i].status);
>                 }
>
>                 /* Decode the payload packet.
> diff --git a/drivers/media/usb/uvc/uvc_queue.c b/drivers/media/usb/uvc/uvc_queue.c
> index 2255daa3e240..21a907d32bb7 100644
> --- a/drivers/media/usb/uvc/uvc_queue.c
> +++ b/drivers/media/usb/uvc/uvc_queue.c
> @@ -103,8 +103,8 @@ static int uvc_buffer_prepare(struct vb2_buffer *vb)
>
>         if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
>             vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
> -               uvc_trace(uvc_queue_to_stream(queue)->dev, UVC_TRACE_CAPTURE,
> -                         "[E] Bytes used out of bounds.\n");
> +               uvc_dbg(uvc_queue_to_stream(queue)->dev, CAPTURE,
> +                       "[E] Bytes used out of bounds\n");
>                 return -EINVAL;
>         }
>
> diff --git a/drivers/media/usb/uvc/uvc_status.c b/drivers/media/usb/uvc/uvc_status.c
> index b5f493216fcd..d65666bc68f3 100644
> --- a/drivers/media/usb/uvc/uvc_status.c
> +++ b/drivers/media/usb/uvc/uvc_status.c
> @@ -93,22 +93,21 @@ static void uvc_event_streaming(struct uvc_device *dev,
>                                 struct uvc_streaming_status *status, int len)
>  {
>         if (len < 3) {
> -               uvc_trace(dev, UVC_TRACE_STATUS,
> -                         "Invalid streaming status event received.\n");
> +               uvc_dbg(dev, STATUS,
> +                       "Invalid streaming status event received\n");
>                 return;
>         }
>
>         if (status->bEvent == 0) {
>                 if (len < 4)
>                         return;
> -               uvc_trace(dev, UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n",
> -                         status->bOriginator,
> -                         status->bValue[0] ? "pressed" : "released", len);
> +               uvc_dbg(dev, STATUS, "Button (intf %u) %s len %d\n",
> +                       status->bOriginator,
> +                       status->bValue[0] ? "pressed" : "released", len);
>                 uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]);
>         } else {
> -               uvc_trace(dev, UVC_TRACE_STATUS,
> -                         "Stream %u error event %02x len %d.\n",
> -                         status->bOriginator, status->bEvent, len);
> +               uvc_dbg(dev, STATUS, "Stream %u error event %02x len %d\n",
> +                       status->bOriginator, status->bEvent, len);
>         }
>  }
>
> @@ -163,14 +162,13 @@ static bool uvc_event_control(struct urb *urb,
>
>         if (len < 6 || status->bEvent != 0 ||
>             status->bAttribute >= ARRAY_SIZE(attrs)) {
> -               uvc_trace(dev, UVC_TRACE_STATUS,
> -                         "Invalid control status event received.\n");
> +               uvc_dbg(dev, STATUS, "Invalid control status event received\n");
>                 return false;
>         }
>
> -       uvc_trace(dev, UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n",
> -                 status->bOriginator, status->bSelector,
> -                 attrs[status->bAttribute], len);
> +       uvc_dbg(dev, STATUS, "Control %u/%u %s change len %d\n",
> +               status->bOriginator, status->bSelector,
> +               attrs[status->bAttribute], len);
>
>         /* Find the control. */
>         ctrl = uvc_event_find_ctrl(dev, status, &chain);
> @@ -236,9 +234,8 @@ static void uvc_status_complete(struct urb *urb)
>                 }
>
>                 default:
> -                       uvc_trace(dev, UVC_TRACE_STATUS,
> -                                 "Unknown status event type %u.\n",
> -                                 dev->status[0]);
> +                       uvc_dbg(dev, STATUS, "Unknown status event type %u\n",
> +                               dev->status[0]);
>                         break;
>                 }
>         }
> diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
> index 3a2d17bc766b..2b8cbb4730e0 100644
> --- a/drivers/media/usb/uvc/uvc_v4l2.c
> +++ b/drivers/media/usb/uvc/uvc_v4l2.c
> @@ -75,9 +75,8 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
>                 break;
>
>         default:
> -               uvc_trace(chain->dev, UVC_TRACE_CONTROL,
> -                         "Unsupported V4L2 control type %u.\n",
> -                         xmap->v4l2_type);
> +               uvc_dbg(chain->dev, CONTROL,
> +                       "Unsupported V4L2 control type %u\n", xmap->v4l2_type);
>                 ret = -ENOTTY;
>                 goto free_map;
>         }
> @@ -165,11 +164,10 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
>                 return -EINVAL;
>
>         fcc = (u8 *)&fmt->fmt.pix.pixelformat;
> -       uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                 "Trying format 0x%08x (%c%c%c%c): %ux%u.\n",
> -                 fmt->fmt.pix.pixelformat,
> -                 fcc[0], fcc[1], fcc[2], fcc[3],
> -                 fmt->fmt.pix.width, fmt->fmt.pix.height);
> +       uvc_dbg(stream->dev, FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u\n",
> +               fmt->fmt.pix.pixelformat,
> +               fcc[0], fcc[1], fcc[2], fcc[3],
> +               fmt->fmt.pix.width, fmt->fmt.pix.height);
>
>         /* Check if the hardware supports the requested format, use the default
>          * format otherwise.
> @@ -209,18 +207,17 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
>         }
>
>         if (frame == NULL) {
> -               uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                         "Unsupported size %ux%u.\n", fmt->fmt.pix.width,
> -                         fmt->fmt.pix.height);
> +               uvc_dbg(stream->dev, FORMAT, "Unsupported size %ux%u\n",
> +                       fmt->fmt.pix.width, fmt->fmt.pix.height);
>                 return -EINVAL;
>         }
>
>         /* Use the default frame interval. */
>         interval = frame->dwDefaultFrameInterval;
> -       uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                 "Using default frame interval %u.%u us (%u.%u fps).\n",
> -                 interval / 10, interval % 10, 10000000 / interval,
> -                (100000000 / interval) % 10);
> +       uvc_dbg(stream->dev, FORMAT,
> +               "Using default frame interval %u.%u us (%u.%u fps)\n",
> +               interval / 10, interval % 10, 10000000 / interval,
> +               (100000000 / interval) % 10);
>
>         /* Set the format index, frame index and frame interval. */
>         memset(probe, 0, sizeof(*probe));
> @@ -262,9 +259,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
>         }
>
>         if (i == stream->nformats) {
> -               uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                         "Unknown bFormatIndex %u\n",
> -                         probe->bFormatIndex);
> +               uvc_dbg(stream->dev, FORMAT, "Unknown bFormatIndex %u\n",
> +                       probe->bFormatIndex);
>                 return -EINVAL;
>         }
>
> @@ -276,9 +272,8 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
>         }
>
>         if (i == format->nframes) {
> -               uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                         "Unknown bFrameIndex %u\n",
> -                         probe->bFrameIndex);
> +               uvc_dbg(stream->dev, FORMAT, "Unknown bFrameIndex %u\n",
> +                       probe->bFrameIndex);
>                 return -EINVAL;
>         }
>
> @@ -422,9 +417,8 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
>
>         interval = uvc_fraction_to_interval(timeperframe.numerator,
>                 timeperframe.denominator);
> -       uvc_trace(stream->dev, UVC_TRACE_FORMAT,
> -                 "Setting frame interval to %u/%u (%u).\n",
> -                 timeperframe.numerator, timeperframe.denominator, interval);
> +       uvc_dbg(stream->dev, FORMAT, "Setting frame interval to %u/%u (%u)\n",
> +               timeperframe.numerator, timeperframe.denominator, interval);
>
>         mutex_lock(&stream->mutex);
>
> @@ -553,7 +547,7 @@ static int uvc_v4l2_open(struct file *file)
>         int ret = 0;
>
>         stream = video_drvdata(file);
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
> +       uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
>
>         ret = usb_autopm_get_interface(stream->dev->intf);
>         if (ret < 0)
> @@ -595,7 +589,7 @@ static int uvc_v4l2_release(struct file *file)
>         struct uvc_fh *handle = file->private_data;
>         struct uvc_streaming *stream = handle->stream;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
> +       uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
>
>         /* Only free resources if this is a privileged handle. */
>         if (uvc_has_privileges(handle))
> @@ -1471,8 +1465,7 @@ static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
>         struct uvc_fh *handle = file->private_data;
>         struct uvc_streaming *stream = handle->stream;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS,
> -                 "uvc_v4l2_read: not implemented.\n");
> +       uvc_dbg(stream->dev, CALLS, "%s: not implemented\n", __func__);
>         return -EINVAL;
>  }
>
> @@ -1481,7 +1474,7 @@ static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
>         struct uvc_fh *handle = file->private_data;
>         struct uvc_streaming *stream = handle->stream;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
> +       uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
>
>         return uvc_queue_mmap(&stream->queue, vma);
>  }
> @@ -1491,7 +1484,7 @@ static __poll_t uvc_v4l2_poll(struct file *file, poll_table *wait)
>         struct uvc_fh *handle = file->private_data;
>         struct uvc_streaming *stream = handle->stream;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
> +       uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
>
>         return uvc_queue_poll(&stream->queue, file, wait);
>  }
> @@ -1504,7 +1497,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
>         struct uvc_fh *handle = file->private_data;
>         struct uvc_streaming *stream = handle->stream;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CALLS, "%s\n", __func__);
> +       uvc_dbg(stream->dev, CALLS, "%s\n", __func__);
>
>         return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
>  }
> diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
> index e44fcb645516..7189624e1ec7 100644
> --- a/drivers/media/usb/uvc/uvc_video.c
> +++ b/drivers/media/usb/uvc/uvc_video.c
> @@ -95,7 +95,7 @@ int uvc_query_ctrl(struct uvc_device *dev, u8 query, u8 unit,
>         if (ret != 1)
>                 return ret < 0 ? ret : -EPIPE;
>
> -       uvc_trace(dev, UVC_TRACE_CONTROL, "Control error %u\n", error);
> +       uvc_dbg(dev, CONTROL, "Control error %u\n", error);
>
>         switch (error) {
>         case 0:
> @@ -705,12 +705,12 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
>
>         sof = y;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CLOCK,
> -                 "%s: PTS %u y %llu.%06llu SOF %u.%06llu (x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
> -                 stream->dev->name, buf->pts,
> -                 y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
> -                 sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
> -                 x1, x2, y1, y2, clock->sof_offset);
> +       uvc_dbg(stream->dev, CLOCK,
> +               "%s: PTS %u y %llu.%06llu SOF %u.%06llu (x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
> +               stream->dev->name, buf->pts,
> +               y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
> +               sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
> +               x1, x2, y1, y2, clock->sof_offset);
>
>         /* Second step, SOF to host clock conversion. */
>         x1 = (uvc_video_clock_host_sof(first) + 2048) << 16;
> @@ -740,13 +740,13 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
>
>         timestamp = ktime_to_ns(first->host_time) + y - y1;
>
> -       uvc_trace(stream->dev, UVC_TRACE_CLOCK,
> -                 "%s: SOF %u.%06llu y %llu ts %llu buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
> -                 stream->dev->name,
> -                 sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
> -                 y, timestamp, vbuf->vb2_buf.timestamp,
> -                 x1, first->host_sof, first->dev_sof,
> -                 x2, last->host_sof, last->dev_sof, y1, y2);
> +       uvc_dbg(stream->dev, CLOCK,
> +               "%s: SOF %u.%06llu y %llu ts %llu buf ts %llu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
> +               stream->dev->name,
> +               sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
> +               y, timestamp, vbuf->vb2_buf.timestamp,
> +               x1, first->host_sof, first->dev_sof,
> +               x2, last->host_sof, last->dev_sof, y1, y2);
>
>         /* Update the V4L2 buffer. */
>         vbuf->vb2_buf.timestamp = timestamp;
> @@ -875,15 +875,15 @@ static void uvc_video_stats_update(struct uvc_streaming *stream)
>  {
>         struct uvc_stats_frame *frame = &stream->stats.frame;
>
> -       uvc_trace(stream->dev, UVC_TRACE_STATS,
> -                 "frame %u stats: %u/%u/%u packets, %u/%u/%u pts (%searly %sinitial), %u/%u scr, last pts/stc/sof %u/%u/%u\n",
> -                 stream->sequence, frame->first_data,
> -                 frame->nb_packets - frame->nb_empty, frame->nb_packets,
> -                 frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
> -                 frame->has_early_pts ? "" : "!",
> -                 frame->has_initial_pts ? "" : "!",
> -                 frame->nb_scr_diffs, frame->nb_scr,
> -                 frame->pts, frame->scr_stc, frame->scr_sof);
> +       uvc_dbg(stream->dev, STATS,
> +               "frame %u stats: %u/%u/%u packets, %u/%u/%u pts (%searly %sinitial), %u/%u scr, last pts/stc/sof %u/%u/%u\n",
> +               stream->sequence, frame->first_data,
> +               frame->nb_packets - frame->nb_empty, frame->nb_packets,
> +               frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
> +               frame->has_early_pts ? "" : "!",
> +               frame->has_initial_pts ? "" : "!",
> +               frame->nb_scr_diffs, frame->nb_scr,
> +               frame->pts, frame->scr_stc, frame->scr_sof);
>
>         stream->stats.stream.nb_frames++;
>         stream->stats.stream.nb_packets += stream->stats.frame.nb_packets;
> @@ -1038,8 +1038,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
>
>         /* Mark the buffer as bad if the error bit is set. */
>         if (data[1] & UVC_STREAM_ERR) {
> -               uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                         "Marking buffer as bad (error bit set).\n");
> +               uvc_dbg(stream->dev, FRAME,
> +                       "Marking buffer as bad (error bit set)\n");
>                 buf->error = 1;
>         }
>
> @@ -1053,8 +1053,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
>          */
>         if (buf->state != UVC_BUF_STATE_ACTIVE) {
>                 if (fid == stream->last_fid) {
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "Dropping payload (out of sync).\n");
> +                       uvc_dbg(stream->dev, FRAME,
> +                               "Dropping payload (out of sync)\n");
>                         if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
>                             (data[1] & UVC_STREAM_EOF))
>                                 stream->last_fid ^= UVC_STREAM_FID;
> @@ -1085,8 +1085,8 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
>          * previous payload had the EOF bit set.
>          */
>         if (fid != stream->last_fid && buf->bytesused != 0) {
> -               uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                         "Frame complete (FID bit toggled).\n");
> +               uvc_dbg(stream->dev, FRAME,
> +                       "Frame complete (FID bit toggled)\n");
>                 buf->state = UVC_BUF_STATE_READY;
>                 return -EAGAIN;
>         }
> @@ -1147,8 +1147,8 @@ static void uvc_video_decode_data(struct uvc_urb *uvc_urb,
>
>         /* Complete the current frame if the buffer size was exceeded. */
>         if (len > maxlen) {
> -               uvc_trace(uvc_urb->stream->dev, UVC_TRACE_FRAME,
> -                         "Frame complete (overflow).\n");
> +               uvc_dbg(uvc_urb->stream->dev, FRAME,
> +                       "Frame complete (overflow)\n");
>                 buf->error = 1;
>                 buf->state = UVC_BUF_STATE_READY;
>         }
> @@ -1161,11 +1161,9 @@ static void uvc_video_decode_end(struct uvc_streaming *stream,
>  {
>         /* Mark the buffer as done if the EOF marker is set. */
>         if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
> -               uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                         "Frame complete (EOF found).\n");
> +               uvc_dbg(stream->dev, FRAME, "Frame complete (EOF found)\n");
>                 if (data[0] == len)
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "EOF in empty payload.\n");
> +                       uvc_dbg(stream->dev, FRAME, "EOF in empty payload\n");
>                 buf->state = UVC_BUF_STATE_READY;
>                 if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
>                         stream->last_fid ^= UVC_STREAM_FID;
> @@ -1281,13 +1279,13 @@ static void uvc_video_decode_meta(struct uvc_streaming *stream,
>         memcpy(&meta->length, mem, length);
>         meta_buf->bytesused += length + sizeof(meta->ns) + sizeof(meta->sof);
>
> -       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                 "%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n",
> -                 __func__, ktime_to_ns(time), meta->sof, meta->length,
> -                 meta->flags,
> -                 has_pts ? *(u32 *)meta->buf : 0,
> -                 has_scr ? *(u32 *)scr : 0,
> -                 has_scr ? *(u32 *)(scr + 4) & 0x7ff : 0);
> +       uvc_dbg(stream->dev, FRAME,
> +               "%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n",
> +               __func__, ktime_to_ns(time), meta->sof, meta->length,
> +               meta->flags,
> +               has_pts ? *(u32 *)meta->buf : 0,
> +               has_scr ? *(u32 *)scr : 0,
> +               has_scr ? *(u32 *)(scr + 4) & 0x7ff : 0);
>  }
>
>  /* ------------------------------------------------------------------------
> @@ -1341,9 +1339,9 @@ static void uvc_video_decode_isoc(struct uvc_urb *uvc_urb,
>
>         for (i = 0; i < urb->number_of_packets; ++i) {
>                 if (urb->iso_frame_desc[i].status < 0) {
> -                       uvc_trace(stream->dev, UVC_TRACE_FRAME,
> -                                 "USB isochronous frame lost (%d).\n",
> -                                 urb->iso_frame_desc[i].status);
> +                       uvc_dbg(stream->dev, FRAME,
> +                               "USB isochronous frame lost (%d)\n",
> +                               urb->iso_frame_desc[i].status);
>                         /* Mark the buffer as faulty. */
>                         if (buf != NULL)
>                                 buf->error = 1;
> @@ -1631,16 +1629,16 @@ static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
>                 }
>
>                 if (i == UVC_URBS) {
> -                       uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                                 "Allocated %u URB buffers of %ux%u bytes each.\n",
> -                                 UVC_URBS, npackets, psize);
> +                       uvc_dbg(stream->dev, VIDEO,
> +                               "Allocated %u URB buffers of %ux%u bytes each\n",
> +                               UVC_URBS, npackets, psize);
>                         return npackets;
>                 }
>         }
>
> -       uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                 "Failed to allocate URB buffers (%u bytes per packet).\n",
> -                 psize);
> +       uvc_dbg(stream->dev, VIDEO,
> +               "Failed to allocate URB buffers (%u bytes per packet)\n",
> +               psize);
>         return 0;
>  }
>
> @@ -1839,13 +1837,13 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
>                 bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
>
>                 if (bandwidth == 0) {
> -                       uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                                 "Device requested null bandwidth, defaulting to lowest.\n");
> +                       uvc_dbg(stream->dev, VIDEO,
> +                               "Device requested null bandwidth, defaulting to lowest\n");
>                         bandwidth = 1;
>                 } else {
> -                       uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                                 "Device requested %u B/frame bandwidth.\n",
> -                                 bandwidth);
> +                       uvc_dbg(stream->dev, VIDEO,
> +                               "Device requested %u B/frame bandwidth\n",
> +                               bandwidth);
>                 }
>
>                 for (i = 0; i < intf->num_altsetting; ++i) {
> @@ -1868,14 +1866,14 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
>                 }
>
>                 if (best_ep == NULL) {
> -                       uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                                 "No fast enough alt setting for requested bandwidth.\n");
> +                       uvc_dbg(stream->dev, VIDEO,
> +                               "No fast enough alt setting for requested bandwidth\n");
>                         return -EIO;
>                 }
>
> -               uvc_trace(stream->dev, UVC_TRACE_VIDEO,
> -                         "Selecting alternate setting %u (%u B/frame bandwidth).\n",
> -                         altsetting, best_psize);
> +               uvc_dbg(stream->dev, VIDEO,
> +                       "Selecting alternate setting %u (%u B/frame bandwidth)\n",
> +                       altsetting, best_psize);
>
>                 ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
>                 if (ret < 0)
> diff --git a/drivers/media/usb/uvc/uvcvideo.h b/drivers/media/usb/uvc/uvcvideo.h
> index 63f7e88c5713..1ca16c95ba25 100644
> --- a/drivers/media/usb/uvc/uvcvideo.h
> +++ b/drivers/media/usb/uvc/uvcvideo.h
> @@ -731,18 +731,18 @@ struct uvc_driver {
>   * Debugging, printing and logging
>   */
>
> -#define UVC_TRACE_PROBE                (1 << 0)
> -#define UVC_TRACE_DESCR                (1 << 1)
> -#define UVC_TRACE_CONTROL      (1 << 2)
> -#define UVC_TRACE_FORMAT       (1 << 3)
> -#define UVC_TRACE_CAPTURE      (1 << 4)
> -#define UVC_TRACE_CALLS                (1 << 5)
> -#define UVC_TRACE_FRAME                (1 << 7)
> -#define UVC_TRACE_SUSPEND      (1 << 8)
> -#define UVC_TRACE_STATUS       (1 << 9)
> -#define UVC_TRACE_VIDEO                (1 << 10)
> -#define UVC_TRACE_STATS                (1 << 11)
> -#define UVC_TRACE_CLOCK                (1 << 12)
> +#define UVC_DBG_PROBE          (1 << 0)
> +#define UVC_DBG_DESCR          (1 << 1)
> +#define UVC_DBG_CONTROL                (1 << 2)
> +#define UVC_DBG_FORMAT         (1 << 3)
> +#define UVC_DBG_CAPTURE                (1 << 4)
> +#define UVC_DBG_CALLS          (1 << 5)
> +#define UVC_DBG_FRAME          (1 << 7)
> +#define UVC_DBG_SUSPEND                (1 << 8)
> +#define UVC_DBG_STATUS         (1 << 9)
> +#define UVC_DBG_VIDEO          (1 << 10)
> +#define UVC_DBG_STATS          (1 << 11)
> +#define UVC_DBG_CLOCK          (1 << 12)
>
>  #define UVC_WARN_MINMAX                0
>  #define UVC_WARN_PROBE_DEF     1
> @@ -750,20 +750,20 @@ struct uvc_driver {
>
>  extern unsigned int uvc_clock_param;
>  extern unsigned int uvc_no_drop_param;
> -extern unsigned int uvc_trace_param;
> +extern unsigned int uvc_dbg_param;
>  extern unsigned int uvc_timeout_param;
>  extern unsigned int uvc_hw_timestamps_param;
>
> -#define uvc_trace(_dev, flag, fmt, ...)                                        \
> +#define uvc_dbg(_dev, flag, fmt, ...)                                  \
>  do {                                                                   \
> -       if (uvc_trace_param & flag)                                     \
> +       if (uvc_dbg_param & UVC_DBG_##flag)                             \
>                 dev_printk(KERN_DEBUG, &(_dev)->udev->dev, fmt,         \
>                            ##__VA_ARGS__);                              \
>  } while (0)
>
> -#define uvc_trace_cont(flag, fmt, ...)                                 \
> +#define uvc_dbg_cont(flag, fmt, ...)                                   \
>  do {                                                                   \
> -       if (uvc_trace_param & flag)                                     \
> +       if (uvc_dbg_param & UVC_DBG_##flag)                             \
>                 pr_cont(fmt, ##__VA_ARGS__);                            \
>  } while (0)
>
>


-- 
Ricardo Ribalda