microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

media: uvcvideo: Rename debug functions 

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

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
This commit is contained in:
Joe Perches 2020-12-23 14:35:27 +01:00 коммит произвёл Mauro Carvalho Chehab
Родитель ed4c5fa4d8
Коммит 9e56380ae6
8 изменённых файлов: 333 добавлений и 352 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

81
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) if (ctrl == NULL && !next)
uvc_trace(chain->dev, UVC_TRACE_CONTROL, uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",
"Control 0x%08x not found.\n", v4l2_id); v4l2_id);
return ctrl; return ctrl;
} }
@ -1800,9 +1800,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, ret = uvc_query_ctrl(dev, UVC_GET_LEN, ctrl->entity->id, dev->intfnum,
info->selector, data, 2); info->selector, data, 2);
if (ret < 0) { if (ret < 0) {
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"GET_LEN failed on control %pUl/%u (%d).\n", "GET_LEN failed on control %pUl/%u (%d)\n",
info->entity, info->selector, ret); info->entity, info->selector, ret);
goto done; goto done;
} }
@ -1813,20 +1813,20 @@ static int uvc_ctrl_fill_xu_info(struct uvc_device *dev,
ret = uvc_ctrl_get_flags(dev, ctrl, info); ret = uvc_ctrl_get_flags(dev, ctrl, info);
if (ret < 0) { if (ret < 0) {
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"Failed to get flags for control %pUl/%u (%d).\n", "Failed to get flags for control %pUl/%u (%d)\n",
info->entity, info->selector, ret); info->entity, info->selector, ret);
goto done; goto done;
} }
uvc_ctrl_fixup_xu_info(dev, ctrl, info); uvc_ctrl_fixup_xu_info(dev, ctrl, info);
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }.\n", "XU control %pUl/%u queried: len %u, flags { get %u set %u auto %u }\n",
info->entity, info->selector, info->size, info->entity, info->selector, info->size,
(info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0, (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
(info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0, (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
(info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0); (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
done: done:
kfree(data); kfree(data);
@ -1851,10 +1851,10 @@ static int uvc_ctrl_init_xu_ctrl(struct uvc_device *dev,
ret = uvc_ctrl_add_info(dev, ctrl, &info); ret = uvc_ctrl_add_info(dev, ctrl, &info);
if (ret < 0) if (ret < 0)
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"Failed to initialize control %pUl/%u on device %s entity %u\n", "Failed to initialize control %pUl/%u on device %s entity %u\n",
info.entity, info.selector, dev->udev->devpath, info.entity, info.selector, dev->udev->devpath,
ctrl->entity->id); ctrl->entity->id);
return ret; return ret;
} }
@ -1882,8 +1882,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
} }
if (!found) { if (!found) {
uvc_trace(chain->dev, UVC_TRACE_CONTROL, uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",
"Extension unit %u not found.\n", xqry->unit); xqry->unit);
return -ENOENT; return -ENOENT;
} }
@ -1898,9 +1898,8 @@ int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
} }
if (!found) { if (!found) {
uvc_trace(chain->dev, UVC_TRACE_CONTROL, uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",
"Control %pUl/%u not found.\n", entity->guid, entity->guid, xqry->selector);
xqry->selector);
return -ENOENT; return -ENOENT;
} }
@ -2048,10 +2047,9 @@ static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
ctrl->initialized = 1; ctrl->initialized = 1;
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL, "Added control %pUl/%u to device %s entity %u\n",
"Added control %pUl/%u to device %s entity %u\n", ctrl->info.entity, ctrl->info.selector, dev->udev->devpath,
ctrl->info.entity, ctrl->info.selector, dev->udev->devpath, ctrl->entity->id);
ctrl->entity->id);
return 0; return 0;
} }
@ -2088,9 +2086,8 @@ static int __uvc_ctrl_add_mapping(struct uvc_device *dev,
map->set = uvc_set_le_value; map->set = uvc_set_le_value;
list_add_tail(&map->list, &ctrl->info.mappings); list_add_tail(&map->list, &ctrl->info.mappings);
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL, "Adding mapping '%s' to control %pUl/%u\n",
"Adding mapping '%s' to control %pUl/%u.\n", map->name, ctrl->info.entity, ctrl->info.selector);
map->name, ctrl->info.entity, ctrl->info.selector);
return 0; return 0;
} }
@ -2106,9 +2103,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
int ret; int ret;
if (mapping->id & ~V4L2_CTRL_ID_MASK) { if (mapping->id & ~V4L2_CTRL_ID_MASK) {
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"Can't add mapping '%s', control id 0x%08x is invalid.\n", "Can't add mapping '%s', control id 0x%08x is invalid\n",
mapping->name, mapping->id); mapping->name, mapping->id);
return -EINVAL; return -EINVAL;
} }
@ -2153,9 +2150,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
list_for_each_entry(map, &ctrl->info.mappings, list) { list_for_each_entry(map, &ctrl->info.mappings, list) {
if (mapping->id == map->id) { if (mapping->id == map->id) {
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"Can't add mapping '%s', control id 0x%08x already exists.\n", "Can't add mapping '%s', control id 0x%08x already exists\n",
mapping->name, mapping->id); mapping->name, mapping->id);
ret = -EEXIST; ret = -EEXIST;
goto done; goto done;
} }
@ -2164,9 +2161,9 @@ int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
/* Prevent excess memory consumption */ /* Prevent excess memory consumption */
if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) { if (atomic_inc_return(&dev->nmappings) > UVC_MAX_CONTROL_MAPPINGS) {
atomic_dec(&dev->nmappings); atomic_dec(&dev->nmappings);
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"Can't add mapping '%s', maximum mappings count (%u) exceeded.\n", "Can't add mapping '%s', maximum mappings count (%u) exceeded\n",
mapping->name, UVC_MAX_CONTROL_MAPPINGS); mapping->name, UVC_MAX_CONTROL_MAPPINGS);
ret = -ENOMEM; ret = -ENOMEM;
goto done; goto done;
} }
@ -2235,9 +2232,9 @@ static void uvc_ctrl_prune_entity(struct uvc_device *dev,
!uvc_test_bit(controls, blacklist[i].index)) !uvc_test_bit(controls, blacklist[i].index))
continue; continue;
uvc_trace(dev, UVC_TRACE_CONTROL, uvc_dbg(dev, CONTROL,
"%u/%u control is black listed, removing it.\n", "%u/%u control is black listed, removing it\n",
entity->id, blacklist[i].index); entity->id, blacklist[i].index);
uvc_clear_bit(controls, blacklist[i].index); uvc_clear_bit(controls, blacklist[i].index);
} }

343
drivers/media/usb/uvc/uvc_driver.c
Просмотреть файл

@ -32,7 +32,7 @@ unsigned int uvc_clock_param = CLOCK_MONOTONIC;
unsigned int uvc_hw_timestamps_param; unsigned int uvc_hw_timestamps_param;
unsigned int uvc_no_drop_param; unsigned int uvc_no_drop_param;
static unsigned int uvc_quirks_param = -1; 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; unsigned int uvc_timeout_param = UVC_CTRL_STREAMING_TIMEOUT;
/* ------------------------------------------------------------------------ /* ------------------------------------------------------------------------
@ -520,10 +520,10 @@ static int uvc_parse_format(struct uvc_device *dev,
case UVC_VS_FORMAT_FRAME_BASED: case UVC_VS_FORMAT_FRAME_BASED:
n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28; n = buffer[2] == UVC_VS_FORMAT_UNCOMPRESSED ? 27 : 28;
if (buflen < n) { if (buflen < n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d FORMAT error\n", "device %d videostreaming interface %d FORMAT error\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber); alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -584,10 +584,10 @@ static int uvc_parse_format(struct uvc_device *dev,
case UVC_VS_FORMAT_MJPEG: case UVC_VS_FORMAT_MJPEG:
if (buflen < 11) { if (buflen < 11) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d FORMAT error\n", "device %d videostreaming interface %d FORMAT error\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber); alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -600,10 +600,10 @@ static int uvc_parse_format(struct uvc_device *dev,
case UVC_VS_FORMAT_DV: case UVC_VS_FORMAT_DV:
if (buflen < 9) { if (buflen < 9) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d FORMAT error\n", "device %d videostreaming interface %d FORMAT error\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber); alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -618,10 +618,10 @@ static int uvc_parse_format(struct uvc_device *dev,
strscpy(format->name, "HD-DV", sizeof(format->name)); strscpy(format->name, "HD-DV", sizeof(format->name));
break; break;
default: default:
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d: unknown DV format %u\n", "device %d videostreaming interface %d: unknown DV format %u\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber, buffer[8]); alts->desc.bInterfaceNumber, buffer[8]);
return -EINVAL; return -EINVAL;
} }
@ -647,14 +647,14 @@ static int uvc_parse_format(struct uvc_device *dev,
case UVC_VS_FORMAT_STREAM_BASED: case UVC_VS_FORMAT_STREAM_BASED:
/* Not supported yet. */ /* Not supported yet. */
default: default:
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d unsupported format %u\n", "device %d videostreaming interface %d unsupported format %u\n",
dev->udev->devnum, alts->desc.bInterfaceNumber, dev->udev->devnum, alts->desc.bInterfaceNumber,
buffer[2]); buffer[2]);
return -EINVAL; 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]; buflen -= buffer[0];
buffer += buffer[0]; buffer += buffer[0];
@ -673,10 +673,10 @@ static int uvc_parse_format(struct uvc_device *dev,
n = n ? n : 3; n = n ? n : 3;
if (buflen < 26 + 4*n) { if (buflen < 26 + 4*n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d FRAME error\n", "device %d videostreaming interface %d FRAME error\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber); alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -738,10 +738,10 @@ static int uvc_parse_format(struct uvc_device *dev,
frame->dwDefaultFrameInterval; frame->dwDefaultFrameInterval;
} }
uvc_trace(dev, UVC_TRACE_DESCR, "- %ux%u (%u.%u fps)\n", uvc_dbg(dev, DESCR, "- %ux%u (%u.%u fps)\n",
frame->wWidth, frame->wHeight, frame->wWidth, frame->wHeight,
10000000 / frame->dwDefaultFrameInterval, 10000000 / frame->dwDefaultFrameInterval,
(100000000 / frame->dwDefaultFrameInterval) % 10); (100000000 / frame->dwDefaultFrameInterval) % 10);
format->nframes++; format->nframes++;
buflen -= buffer[0]; buflen -= buffer[0];
@ -757,10 +757,10 @@ static int uvc_parse_format(struct uvc_device *dev,
if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE && if (buflen > 2 && buffer[1] == USB_DT_CS_INTERFACE &&
buffer[2] == UVC_VS_COLORFORMAT) { buffer[2] == UVC_VS_COLORFORMAT) {
if (buflen < 6) { if (buflen < 6) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d COLORFORMAT error\n", "device %d videostreaming interface %d COLORFORMAT error\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber); alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -792,18 +792,18 @@ static int uvc_parse_streaming(struct uvc_device *dev,
if (intf->cur_altsetting->desc.bInterfaceSubClass if (intf->cur_altsetting->desc.bInterfaceSubClass
!= UVC_SC_VIDEOSTREAMING) { != UVC_SC_VIDEOSTREAMING) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d interface %d isn't a video streaming interface\n", "device %d interface %d isn't a video streaming interface\n",
dev->udev->devnum, dev->udev->devnum,
intf->altsetting[0].desc.bInterfaceNumber); intf->altsetting[0].desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) { if (usb_driver_claim_interface(&uvc_driver.driver, intf, dev)) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d interface %d is already claimed\n", "device %d interface %d is already claimed\n",
dev->udev->devnum, dev->udev->devnum,
intf->altsetting[0].desc.bInterfaceNumber); intf->altsetting[0].desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -825,9 +825,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
if (ep->extralen > 2 && if (ep->extralen > 2 &&
ep->extra[1] == USB_DT_CS_INTERFACE) { ep->extra[1] == USB_DT_CS_INTERFACE) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"trying extra data from endpoint %u.\n", "trying extra data from endpoint %u\n",
i); i);
buffer = alts->endpoint[i].extra; buffer = alts->endpoint[i].extra;
buflen = alts->endpoint[i].extralen; buflen = alts->endpoint[i].extralen;
break; break;
@ -842,8 +842,8 @@ static int uvc_parse_streaming(struct uvc_device *dev,
} }
if (buflen <= 2) { if (buflen <= 2) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"no class-specific streaming interface descriptors found.\n"); "no class-specific streaming interface descriptors found\n");
goto error; goto error;
} }
@ -860,9 +860,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
break; break;
default: default:
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d HEADER descriptor not found.\n", "device %d videostreaming interface %d HEADER descriptor not found\n",
dev->udev->devnum, alts->desc.bInterfaceNumber); dev->udev->devnum, alts->desc.bInterfaceNumber);
goto error; goto error;
} }
@ -870,9 +870,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
n = buflen >= size ? buffer[size-1] : 0; n = buflen >= size ? buffer[size-1] : 0;
if (buflen < size + p*n) { if (buflen < size + p*n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d HEADER descriptor is invalid.\n", "device %d videostreaming interface %d HEADER descriptor is invalid\n",
dev->udev->devnum, alts->desc.bInterfaceNumber); dev->udev->devnum, alts->desc.bInterfaceNumber);
goto error; goto error;
} }
@ -922,10 +922,10 @@ static int uvc_parse_streaming(struct uvc_device *dev,
case UVC_VS_FORMAT_MPEG2TS: case UVC_VS_FORMAT_MPEG2TS:
case UVC_VS_FORMAT_STREAM_BASED: case UVC_VS_FORMAT_STREAM_BASED:
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d FORMAT %u is not supported.\n", "device %d videostreaming interface %d FORMAT %u is not supported\n",
dev->udev->devnum, dev->udev->devnum,
alts->desc.bInterfaceNumber, _buffer[2]); alts->desc.bInterfaceNumber, _buffer[2]);
break; break;
case UVC_VS_FRAME_UNCOMPRESSED: case UVC_VS_FRAME_UNCOMPRESSED:
@ -947,9 +947,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
} }
if (nformats == 0) { if (nformats == 0) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d has no supported formats defined.\n", "device %d videostreaming interface %d has no supported formats defined\n",
dev->udev->devnum, alts->desc.bInterfaceNumber); dev->udev->devnum, alts->desc.bInterfaceNumber);
goto error; goto error;
} }
@ -996,10 +996,9 @@ static int uvc_parse_streaming(struct uvc_device *dev,
} }
if (buflen) if (buflen)
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videostreaming interface %d has %u bytes of trailing descriptor garbage.\n", "device %d videostreaming interface %d has %u bytes of trailing descriptor garbage\n",
dev->udev->devnum, alts->desc.bInterfaceNumber, dev->udev->devnum, alts->desc.bInterfaceNumber, buflen);
buflen);
/* Parse the alternate settings to find the maximum bandwidth. */ /* Parse the alternate settings to find the maximum bandwidth. */
for (i = 0; i < intf->num_altsetting; ++i) { for (i = 0; i < intf->num_altsetting; ++i) {
@ -1132,9 +1131,9 @@ static int uvc_parse_vendor_control(struct uvc_device *dev,
n = buflen >= 25 + p ? buffer[22+p] : 0; n = buflen >= 25 + p ? buffer[22+p] : 0;
if (buflen < 25 + p + 2*n) { if (buflen < 25 + p + 2*n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d EXTENSION_UNIT error\n", "device %d videocontrol interface %d EXTENSION_UNIT error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
break; break;
} }
@ -1181,9 +1180,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
n = buflen >= 12 ? buffer[11] : 0; n = buflen >= 12 ? buffer[11] : 0;
if (buflen < 12 + n) { if (buflen < 12 + n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d HEADER error\n", "device %d videocontrol interface %d HEADER error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1194,9 +1193,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
for (i = 0; i < n; ++i) { for (i = 0; i < n; ++i) {
intf = usb_ifnum_to_if(udev, buffer[12+i]); intf = usb_ifnum_to_if(udev, buffer[12+i]);
if (intf == NULL) { if (intf == NULL) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d interface %d doesn't exists\n", "device %d interface %d doesn't exists\n",
udev->devnum, i); udev->devnum, i);
continue; continue;
} }
@ -1206,9 +1205,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
case UVC_VC_INPUT_TERMINAL: case UVC_VC_INPUT_TERMINAL:
if (buflen < 8) { if (buflen < 8) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d INPUT_TERMINAL error\n", "device %d videocontrol interface %d INPUT_TERMINAL error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1225,10 +1224,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
*/ */
type = get_unaligned_le16(&buffer[4]); type = get_unaligned_le16(&buffer[4]);
if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) { if ((type & 0x7f00) == 0 || (type & 0x8000) != 0) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n", "device %d videocontrol interface %d INPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
udev->devnum, alts->desc.bInterfaceNumber, udev->devnum, alts->desc.bInterfaceNumber,
buffer[3], type); buffer[3], type);
return 0; return 0;
} }
@ -1247,9 +1246,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
} }
if (buflen < len + n + p) { if (buflen < len + n + p) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d INPUT_TERMINAL error\n", "device %d videocontrol interface %d INPUT_TERMINAL error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1294,9 +1293,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
case UVC_VC_OUTPUT_TERMINAL: case UVC_VC_OUTPUT_TERMINAL:
if (buflen < 9) { if (buflen < 9) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d OUTPUT_TERMINAL error\n", "device %d videocontrol interface %d OUTPUT_TERMINAL error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1305,10 +1304,10 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
*/ */
type = get_unaligned_le16(&buffer[4]); type = get_unaligned_le16(&buffer[4]);
if ((type & 0xff00) == 0) { if ((type & 0xff00) == 0) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n", "device %d videocontrol interface %d OUTPUT_TERMINAL %d has invalid type 0x%04x, skipping\n",
udev->devnum, alts->desc.bInterfaceNumber, udev->devnum, alts->desc.bInterfaceNumber,
buffer[3], type); buffer[3], type);
return 0; return 0;
} }
@ -1332,9 +1331,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
p = buflen >= 5 ? buffer[4] : 0; p = buflen >= 5 ? buffer[4] : 0;
if (buflen < 5 || buflen < 6 + p) { if (buflen < 5 || buflen < 6 + p) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d SELECTOR_UNIT error\n", "device %d videocontrol interface %d SELECTOR_UNIT error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1358,9 +1357,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
p = dev->uvc_version >= 0x0110 ? 10 : 9; p = dev->uvc_version >= 0x0110 ? 10 : 9;
if (buflen < p + n) { if (buflen < p + n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d PROCESSING_UNIT error\n", "device %d videocontrol interface %d PROCESSING_UNIT error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1391,9 +1390,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
n = buflen >= 24 + p ? buffer[22+p] : 0; n = buflen >= 24 + p ? buffer[22+p] : 0;
if (buflen < 24 + p + n) { if (buflen < 24 + p + n) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"device %d videocontrol interface %d EXTENSION_UNIT error\n", "device %d videocontrol interface %d EXTENSION_UNIT error\n",
udev->devnum, alts->desc.bInterfaceNumber); udev->devnum, alts->desc.bInterfaceNumber);
return -EINVAL; return -EINVAL;
} }
@ -1418,9 +1417,9 @@ static int uvc_parse_standard_control(struct uvc_device *dev,
break; break;
default: default:
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"Found an unknown CS_INTERFACE descriptor (%u)\n", "Found an unknown CS_INTERFACE descriptor (%u)\n",
buffer[2]); buffer[2]);
break; break;
} }
@ -1465,9 +1464,9 @@ next_descriptor:
if (usb_endpoint_is_int_in(desc) && if (usb_endpoint_is_int_in(desc) &&
le16_to_cpu(desc->wMaxPacketSize) >= 8 && le16_to_cpu(desc->wMaxPacketSize) >= 8 &&
desc->bInterval != 0) { desc->bInterval != 0) {
uvc_trace(dev, UVC_TRACE_DESCR, uvc_dbg(dev, DESCR,
"Found a Status endpoint (addr %02x).\n", "Found a Status endpoint (addr %02x)\n",
desc->bEndpointAddress); desc->bEndpointAddress);
dev->int_ep = ep; dev->int_ep = ep;
} }
} }
@ -1612,23 +1611,23 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
{ {
switch (UVC_ENTITY_TYPE(entity)) { switch (UVC_ENTITY_TYPE(entity)) {
case UVC_VC_EXTENSION_UNIT: 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) { if (entity->bNrInPins != 1) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Extension unit %d has more than 1 input pin.\n", "Extension unit %d has more than 1 input pin\n",
entity->id); entity->id);
return -1; return -1;
} }
break; break;
case UVC_VC_PROCESSING_UNIT: 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) { if (chain->processing != NULL) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found multiple Processing Units in chain.\n"); "Found multiple Processing Units in chain\n");
return -1; return -1;
} }
@ -1636,15 +1635,15 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
break; break;
case UVC_VC_SELECTOR_UNIT: 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. */ /* Single-input selector units are ignored. */
if (entity->bNrInPins == 1) if (entity->bNrInPins == 1)
break; break;
if (chain->selector != NULL) { if (chain->selector != NULL) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found multiple Selector Units in chain.\n"); "Found multiple Selector Units in chain\n");
return -1; return -1;
} }
@ -1654,29 +1653,29 @@ static int uvc_scan_chain_entity(struct uvc_video_chain *chain,
case UVC_ITT_VENDOR_SPECIFIC: case UVC_ITT_VENDOR_SPECIFIC:
case UVC_ITT_CAMERA: case UVC_ITT_CAMERA:
case UVC_ITT_MEDIA_TRANSPORT_INPUT: 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; break;
case UVC_OTT_VENDOR_SPECIFIC: case UVC_OTT_VENDOR_SPECIFIC:
case UVC_OTT_DISPLAY: case UVC_OTT_DISPLAY:
case UVC_OTT_MEDIA_TRANSPORT_OUTPUT: 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; break;
case UVC_TT_STREAMING: case UVC_TT_STREAMING:
if (UVC_ENTITY_IS_ITERM(entity)) 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 else
uvc_trace_cont(UVC_TRACE_PROBE, " OT %d", entity->id); uvc_dbg_cont(PROBE, " OT %d", entity->id);
break; break;
default: default:
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Unsupported entity type 0x%04x found in chain.\n", "Unsupported entity type 0x%04x found in chain\n",
UVC_ENTITY_TYPE(entity)); UVC_ENTITY_TYPE(entity));
return -1; return -1;
} }
@ -1702,26 +1701,26 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
if (forward == prev) if (forward == prev)
continue; continue;
if (forward->chain.next || forward->chain.prev) { if (forward->chain.next || forward->chain.prev) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found reference to entity %d already in chain.\n", "Found reference to entity %d already in chain\n",
forward->id); forward->id);
return -EINVAL; return -EINVAL;
} }
switch (UVC_ENTITY_TYPE(forward)) { switch (UVC_ENTITY_TYPE(forward)) {
case UVC_VC_EXTENSION_UNIT: case UVC_VC_EXTENSION_UNIT:
if (forward->bNrInPins != 1) { if (forward->bNrInPins != 1) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Extension unit %d has more than 1 input pin.\n", "Extension unit %d has more than 1 input pin\n",
entity->id); entity->id);
return -EINVAL; return -EINVAL;
} }
list_add_tail(&forward->chain, &chain->entities); list_add_tail(&forward->chain, &chain->entities);
if (!found) 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; found = 1;
break; break;
@ -1730,23 +1729,23 @@ static int uvc_scan_chain_forward(struct uvc_video_chain *chain,
case UVC_OTT_MEDIA_TRANSPORT_OUTPUT: case UVC_OTT_MEDIA_TRANSPORT_OUTPUT:
case UVC_TT_STREAMING: case UVC_TT_STREAMING:
if (UVC_ENTITY_IS_ITERM(forward)) { if (UVC_ENTITY_IS_ITERM(forward)) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Unsupported input terminal %u.\n", "Unsupported input terminal %u\n",
forward->id); forward->id);
return -EINVAL; return -EINVAL;
} }
list_add_tail(&forward->chain, &chain->entities); list_add_tail(&forward->chain, &chain->entities);
if (!found) 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; found = 1;
break; break;
} }
} }
if (found) if (found)
uvc_trace_cont(UVC_TRACE_PROBE, ")"); uvc_dbg_cont(PROBE, ")");
return 0; return 0;
} }
@ -1771,33 +1770,33 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
break; break;
} }
uvc_trace_cont(UVC_TRACE_PROBE, " <- IT"); uvc_dbg_cont(PROBE, " <- IT");
chain->selector = entity; chain->selector = entity;
for (i = 0; i < entity->bNrInPins; ++i) { for (i = 0; i < entity->bNrInPins; ++i) {
id = entity->baSourceID[i]; id = entity->baSourceID[i];
term = uvc_entity_by_id(chain->dev, id); term = uvc_entity_by_id(chain->dev, id);
if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) { if (term == NULL || !UVC_ENTITY_IS_ITERM(term)) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Selector unit %d input %d isn't connected to an input terminal\n", "Selector unit %d input %d isn't connected to an input terminal\n",
entity->id, i); entity->id, i);
return -1; return -1;
} }
if (term->chain.next || term->chain.prev) { if (term->chain.next || term->chain.prev) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found reference to entity %d already in chain.\n", "Found reference to entity %d already in chain\n",
term->id); term->id);
return -EINVAL; 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); list_add_tail(&term->chain, &chain->entities);
uvc_scan_chain_forward(chain, term, entity); uvc_scan_chain_forward(chain, term, entity);
} }
uvc_trace_cont(UVC_TRACE_PROBE, "\n"); uvc_dbg_cont(PROBE, "\n");
id = 0; id = 0;
break; break;
@ -1820,8 +1819,8 @@ static int uvc_scan_chain_backward(struct uvc_video_chain *chain,
entity = uvc_entity_by_id(chain->dev, id); entity = uvc_entity_by_id(chain->dev, id);
if (entity == NULL) { if (entity == NULL) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found reference to unknown entity %d.\n", id); "Found reference to unknown entity %d\n", id);
return -EINVAL; return -EINVAL;
} }
@ -1834,7 +1833,7 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
{ {
struct uvc_entity *entity, *prev; 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; entity = term;
prev = NULL; prev = NULL;
@ -1842,9 +1841,9 @@ static int uvc_scan_chain(struct uvc_video_chain *chain,
while (entity != NULL) { while (entity != NULL) {
/* Entity must not be part of an existing chain */ /* Entity must not be part of an existing chain */
if (entity->chain.next || entity->chain.prev) { if (entity->chain.next || entity->chain.prev) {
uvc_trace(chain->dev, UVC_TRACE_DESCR, uvc_dbg(chain->dev, DESCR,
"Found reference to entity %d already in chain.\n", "Found reference to entity %d already in chain\n",
entity->id); entity->id);
return -EINVAL; return -EINVAL;
} }
@ -1998,9 +1997,8 @@ static int uvc_scan_fallback(struct uvc_device *dev)
list_add_tail(&chain->list, &dev->chains); list_add_tail(&chain->list, &dev->chains);
uvc_trace(dev, UVC_TRACE_PROBE, uvc_dbg(dev, PROBE, "Found a video chain by fallback heuristic (%s)\n",
"Found a video chain by fallback heuristic (%s).\n", uvc_print_chain(chain));
uvc_print_chain(chain));
return 0; return 0;
@ -2042,9 +2040,8 @@ static int uvc_scan_device(struct uvc_device *dev)
continue; continue;
} }
uvc_trace(dev, UVC_TRACE_PROBE, uvc_dbg(dev, PROBE, "Found a valid video chain (%s)\n",
"Found a valid video chain (%s).\n", uvc_print_chain(chain));
uvc_print_chain(chain));
list_add_tail(&chain->list, &dev->chains); list_add_tail(&chain->list, &dev->chains);
} }
@ -2344,12 +2341,11 @@ static int uvc_probe(struct usb_interface *intf,
? dev->info->quirks : uvc_quirks_param; ? dev->info->quirks : uvc_quirks_param;
if (id->idVendor && id->idProduct) if (id->idVendor && id->idProduct)
uvc_trace(dev, UVC_TRACE_PROBE, uvc_dbg(dev, PROBE, "Probing known UVC device %s (%04x:%04x)\n",
"Probing known UVC device %s (%04x:%04x)\n", udev->devpath, id->idVendor, id->idProduct);
udev->devpath, id->idVendor, id->idProduct);
else else
uvc_trace(dev, UVC_TRACE_PROBE, uvc_dbg(dev, PROBE, "Probing generic UVC device %s\n",
"Probing generic UVC device %s\n", udev->devpath); udev->devpath);
if (udev->product != NULL) if (udev->product != NULL)
strscpy(dev->name, udev->product, sizeof(dev->name)); strscpy(dev->name, udev->product, sizeof(dev->name));
@ -2393,14 +2389,13 @@ static int uvc_probe(struct usb_interface *intf,
/* Parse the Video Class control descriptor. */ /* Parse the Video Class control descriptor. */
if (uvc_parse_control(dev) < 0) { if (uvc_parse_control(dev) < 0) {
uvc_trace(dev, UVC_TRACE_PROBE, uvc_dbg(dev, PROBE, "Unable to parse UVC descriptors\n");
"Unable to parse UVC descriptors.\n");
goto error; goto error;
} }
/* Parse the associated GPIOs. */ /* Parse the associated GPIOs. */
if (uvc_gpio_parse(dev) < 0) { 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; goto error;
} }
@ -2462,7 +2457,7 @@ static int uvc_probe(struct usb_interface *intf,
goto error; goto error;
} }
uvc_trace(dev, UVC_TRACE_PROBE, "UVC device initialized.\n"); uvc_dbg(dev, PROBE, "UVC device initialized\n");
usb_enable_autosuspend(udev); usb_enable_autosuspend(udev);
return 0; return 0;
@ -2494,7 +2489,7 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
struct uvc_device *dev = usb_get_intfdata(intf); struct uvc_device *dev = usb_get_intfdata(intf);
struct uvc_streaming *stream; 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); intf->cur_altsetting->desc.bInterfaceNumber);
/* Controls are cached on the fly so they don't need to be saved. */ /* Controls are cached on the fly so they don't need to be saved. */
@ -2512,8 +2507,8 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
return uvc_video_suspend(stream); return uvc_video_suspend(stream);
} }
uvc_trace(dev, UVC_TRACE_SUSPEND, uvc_dbg(dev, SUSPEND,
"Suspend: video streaming USB interface mismatch.\n"); "Suspend: video streaming USB interface mismatch\n");
return -EINVAL; return -EINVAL;
} }
@ -2523,8 +2518,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
struct uvc_streaming *stream; struct uvc_streaming *stream;
int ret = 0; int ret = 0;
uvc_trace(dev, UVC_TRACE_SUSPEND, "Resuming interface %u\n", uvc_dbg(dev, SUSPEND, "Resuming interface %u\n",
intf->cur_altsetting->desc.bInterfaceNumber); intf->cur_altsetting->desc.bInterfaceNumber);
if (intf->cur_altsetting->desc.bInterfaceSubClass == if (intf->cur_altsetting->desc.bInterfaceSubClass ==
UVC_SC_VIDEOCONTROL) { UVC_SC_VIDEOCONTROL) {
@ -2552,8 +2547,8 @@ static int __uvc_resume(struct usb_interface *intf, int reset)
} }
} }
uvc_trace(dev, UVC_TRACE_SUSPEND, uvc_dbg(dev, SUSPEND,
"Resume: video streaming USB interface mismatch.\n"); "Resume: video streaming USB interface mismatch\n");
return -EINVAL; return -EINVAL;
} }
@ -2603,7 +2598,7 @@ module_param_named(nodrop, uvc_no_drop_param, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames"); MODULE_PARM_DESC(nodrop, "Don't drop incomplete frames");
module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR); module_param_named(quirks, uvc_quirks_param, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(quirks, "Forced device quirks"); 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_PARM_DESC(trace, "Trace level bitmask");
module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR); module_param_named(timeout, uvc_timeout_param, uint, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(timeout, "Streaming control requests timeout"); MODULE_PARM_DESC(timeout, "Streaming control requests timeout");

17
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) || if ((len >= 14 && memcmp(&data[2], hdr, 12) == 0) ||
(len >= 15 && memcmp(&data[3], hdr, 12) == 0)) { (len >= 15 && memcmp(&data[3], hdr, 12) == 0)) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME, "iSight header found\n");
"iSight header found\n");
is_header = 1; is_header = 1;
} }
/* Synchronize to the input stream by waiting for a header packet. */ /* Synchronize to the input stream by waiting for a header packet. */
if (buf->state != UVC_BUF_STATE_ACTIVE) { if (buf->state != UVC_BUF_STATE_ACTIVE) {
if (!is_header) { if (!is_header) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"Dropping packet (out of sync).\n"); "Dropping packet (out of sync)\n");
return 0; return 0;
} }
@ -87,8 +86,8 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
buf->bytesused += nbytes; buf->bytesused += nbytes;
if (len > maxlen || buf->bytesused == buf->length) { if (len > maxlen || buf->bytesused == buf->length) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"Frame complete (overflow).\n"); "Frame complete (overflow)\n");
buf->state = UVC_BUF_STATE_DONE; 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) { for (i = 0; i < urb->number_of_packets; ++i) {
if (urb->iso_frame_desc[i].status < 0) { if (urb->iso_frame_desc[i].status < 0) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"USB isochronous frame lost (%d).\n", "USB isochronous frame lost (%d)\n",
urb->iso_frame_desc[i].status); urb->iso_frame_desc[i].status);
} }
/* Decode the payload packet. /* Decode the payload packet.

4
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 && if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) { vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
uvc_trace(uvc_queue_to_stream(queue)->dev, UVC_TRACE_CAPTURE, uvc_dbg(uvc_queue_to_stream(queue)->dev, CAPTURE,
"[E] Bytes used out of bounds.\n"); "[E] Bytes used out of bounds\n");
return -EINVAL; return -EINVAL;
} }

29
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) struct uvc_streaming_status *status, int len)
{ {
if (len < 3) { if (len < 3) {
uvc_trace(dev, UVC_TRACE_STATUS, uvc_dbg(dev, STATUS,
"Invalid streaming status event received.\n"); "Invalid streaming status event received\n");
return; return;
} }
if (status->bEvent == 0) { if (status->bEvent == 0) {
if (len < 4) if (len < 4)
return; return;
uvc_trace(dev, UVC_TRACE_STATUS, "Button (intf %u) %s len %d\n", uvc_dbg(dev, STATUS, "Button (intf %u) %s len %d\n",
status->bOriginator, status->bOriginator,
status->bValue[0] ? "pressed" : "released", len); status->bValue[0] ? "pressed" : "released", len);
uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]); uvc_input_report_key(dev, KEY_CAMERA, status->bValue[0]);
} else { } else {
uvc_trace(dev, UVC_TRACE_STATUS, uvc_dbg(dev, STATUS, "Stream %u error event %02x len %d\n",
"Stream %u error event %02x len %d.\n", status->bOriginator, status->bEvent, len);
status->bOriginator, status->bEvent, len);
} }
} }
@ -163,14 +162,13 @@ static bool uvc_event_control(struct urb *urb,
if (len < 6 || status->bEvent != 0 || if (len < 6 || status->bEvent != 0 ||
status->bAttribute >= ARRAY_SIZE(attrs)) { status->bAttribute >= ARRAY_SIZE(attrs)) {
uvc_trace(dev, UVC_TRACE_STATUS, uvc_dbg(dev, STATUS, "Invalid control status event received\n");
"Invalid control status event received.\n");
return false; return false;
} }
uvc_trace(dev, UVC_TRACE_STATUS, "Control %u/%u %s change len %d.\n", uvc_dbg(dev, STATUS, "Control %u/%u %s change len %d\n",
status->bOriginator, status->bSelector, status->bOriginator, status->bSelector,
attrs[status->bAttribute], len); attrs[status->bAttribute], len);
/* Find the control. */ /* Find the control. */
ctrl = uvc_event_find_ctrl(dev, status, &chain); ctrl = uvc_event_find_ctrl(dev, status, &chain);
@ -237,9 +235,8 @@ static void uvc_status_complete(struct urb *urb)
} }
default: default:
uvc_trace(dev, UVC_TRACE_STATUS, uvc_dbg(dev, STATUS, "Unknown status event type %u\n",
"Unknown status event type %u.\n", dev->status[0]);
dev->status[0]);
break; break;
} }
} }

57
drivers/media/usb/uvc/uvc_v4l2.c
Просмотреть файл

@ -75,9 +75,8 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
break; break;
default: default:
uvc_trace(chain->dev, UVC_TRACE_CONTROL, uvc_dbg(chain->dev, CONTROL,
"Unsupported V4L2 control type %u.\n", "Unsupported V4L2 control type %u\n", xmap->v4l2_type);
xmap->v4l2_type);
ret = -ENOTTY; ret = -ENOTTY;
goto free_map; goto free_map;
} }
@ -165,11 +164,10 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
return -EINVAL; return -EINVAL;
fcc = (u8 *)&fmt->fmt.pix.pixelformat; fcc = (u8 *)&fmt->fmt.pix.pixelformat;
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT, "Trying format 0x%08x (%c%c%c%c): %ux%u\n",
"Trying format 0x%08x (%c%c%c%c): %ux%u.\n", fmt->fmt.pix.pixelformat,
fmt->fmt.pix.pixelformat, fcc[0], fcc[1], fcc[2], fcc[3],
fcc[0], fcc[1], fcc[2], fcc[3], fmt->fmt.pix.width, fmt->fmt.pix.height);
fmt->fmt.pix.width, fmt->fmt.pix.height);
/* Check if the hardware supports the requested format, use the default /* Check if the hardware supports the requested format, use the default
* format otherwise. * format otherwise.
@ -209,18 +207,17 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
} }
if (frame == NULL) { if (frame == NULL) {
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT, "Unsupported size %ux%u\n",
"Unsupported size %ux%u.\n", fmt->fmt.pix.width, fmt->fmt.pix.width, fmt->fmt.pix.height);
fmt->fmt.pix.height);
return -EINVAL; return -EINVAL;
} }
/* Use the default frame interval. */ /* Use the default frame interval. */
interval = frame->dwDefaultFrameInterval; interval = frame->dwDefaultFrameInterval;
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT,
"Using default frame interval %u.%u us (%u.%u fps).\n", "Using default frame interval %u.%u us (%u.%u fps)\n",
interval / 10, interval % 10, 10000000 / interval, interval / 10, interval % 10, 10000000 / interval,
(100000000 / interval) % 10); (100000000 / interval) % 10);
/* Set the format index, frame index and frame interval. */ /* Set the format index, frame index and frame interval. */
memset(probe, 0, sizeof(*probe)); memset(probe, 0, sizeof(*probe));
@ -264,9 +261,9 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
} }
if (i == stream->nformats) if (i == stream->nformats)
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT,
"Unknown bFormatIndex %u, using default\n", "Unknown bFormatIndex %u, using default\n",
probe->bFormatIndex); probe->bFormatIndex);
for (i = 0; i < format->nframes; ++i) { for (i = 0; i < format->nframes; ++i) {
if (probe->bFrameIndex == format->frame[i].bFrameIndex) { if (probe->bFrameIndex == format->frame[i].bFrameIndex) {
@ -276,9 +273,9 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
} }
if (i == format->nframes) if (i == format->nframes)
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT,
"Unknown bFrameIndex %u, using default\n", "Unknown bFrameIndex %u, using default\n",
probe->bFrameIndex); probe->bFrameIndex);
fmt->fmt.pix.width = frame->wWidth; fmt->fmt.pix.width = frame->wWidth;
fmt->fmt.pix.height = frame->wHeight; fmt->fmt.pix.height = frame->wHeight;
@ -420,9 +417,8 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
interval = uvc_fraction_to_interval(timeperframe.numerator, interval = uvc_fraction_to_interval(timeperframe.numerator,
timeperframe.denominator); timeperframe.denominator);
uvc_trace(stream->dev, UVC_TRACE_FORMAT, uvc_dbg(stream->dev, FORMAT, "Setting frame interval to %u/%u (%u)\n",
"Setting frame interval to %u/%u (%u).\n", timeperframe.numerator, timeperframe.denominator, interval);
timeperframe.numerator, timeperframe.denominator, interval);
mutex_lock(&stream->mutex); mutex_lock(&stream->mutex);
@ -551,7 +547,7 @@ static int uvc_v4l2_open(struct file *file)
int ret = 0; int ret = 0;
stream = video_drvdata(file); 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); ret = usb_autopm_get_interface(stream->dev->intf);
if (ret < 0) if (ret < 0)
@ -593,7 +589,7 @@ static int uvc_v4l2_release(struct file *file)
struct uvc_fh *handle = file->private_data; struct uvc_fh *handle = file->private_data;
struct uvc_streaming *stream = handle->stream; 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. */ /* Only free resources if this is a privileged handle. */
if (uvc_has_privileges(handle)) if (uvc_has_privileges(handle))
@ -1469,8 +1465,7 @@ static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
struct uvc_fh *handle = file->private_data; struct uvc_fh *handle = file->private_data;
struct uvc_streaming *stream = handle->stream; struct uvc_streaming *stream = handle->stream;
uvc_trace(stream->dev, UVC_TRACE_CALLS, uvc_dbg(stream->dev, CALLS, "%s: not implemented\n", __func__);
"uvc_v4l2_read: not implemented.\n");
return -EINVAL; return -EINVAL;
} }
@ -1479,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_fh *handle = file->private_data;
struct uvc_streaming *stream = handle->stream; 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); return uvc_queue_mmap(&stream->queue, vma);
} }
@ -1489,7 +1484,7 @@ static __poll_t uvc_v4l2_poll(struct file *file, poll_table *wait)
struct uvc_fh *handle = file->private_data; struct uvc_fh *handle = file->private_data;
struct uvc_streaming *stream = handle->stream; 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); return uvc_queue_poll(&stream->queue, file, wait);
} }
@ -1502,7 +1497,7 @@ static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
struct uvc_fh *handle = file->private_data; struct uvc_fh *handle = file->private_data;
struct uvc_streaming *stream = handle->stream; 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); return uvc_queue_get_unmapped_area(&stream->queue, pgoff);
} }

120
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) if (ret != 1)
return ret < 0 ? ret : -EPIPE; 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) { switch (error) {
case 0: case 0:
@ -705,12 +705,12 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
sof = y; sof = y;
uvc_trace(stream->dev, UVC_TRACE_CLOCK, 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", "%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, stream->dev->name, buf->pts,
y >> 16, div_u64((y & 0xffff) * 1000000, 65536), y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536), sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
x1, x2, y1, y2, clock->sof_offset); x1, x2, y1, y2, clock->sof_offset);
/* Second step, SOF to host clock conversion. */ /* Second step, SOF to host clock conversion. */
x1 = (uvc_video_clock_host_sof(first) + 2048) << 16; 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; timestamp = ktime_to_ns(first->host_time) + y - y1;
uvc_trace(stream->dev, UVC_TRACE_CLOCK, 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", "%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, stream->dev->name,
sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536), sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
y, timestamp, vbuf->vb2_buf.timestamp, y, timestamp, vbuf->vb2_buf.timestamp,
x1, first->host_sof, first->dev_sof, x1, first->host_sof, first->dev_sof,
x2, last->host_sof, last->dev_sof, y1, y2); x2, last->host_sof, last->dev_sof, y1, y2);
/* Update the V4L2 buffer. */ /* Update the V4L2 buffer. */
vbuf->vb2_buf.timestamp = timestamp; 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; struct uvc_stats_frame *frame = &stream->stats.frame;
uvc_trace(stream->dev, UVC_TRACE_STATS, 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", "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, stream->sequence, frame->first_data,
frame->nb_packets - frame->nb_empty, frame->nb_packets, frame->nb_packets - frame->nb_empty, frame->nb_packets,
frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts, frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
frame->has_early_pts ? "" : "!", frame->has_early_pts ? "" : "!",
frame->has_initial_pts ? "" : "!", frame->has_initial_pts ? "" : "!",
frame->nb_scr_diffs, frame->nb_scr, frame->nb_scr_diffs, frame->nb_scr,
frame->pts, frame->scr_stc, frame->scr_sof); frame->pts, frame->scr_stc, frame->scr_sof);
stream->stats.stream.nb_frames++; stream->stats.stream.nb_frames++;
stream->stats.stream.nb_packets += stream->stats.frame.nb_packets; 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. */ /* Mark the buffer as bad if the error bit is set. */
if (data[1] & UVC_STREAM_ERR) { if (data[1] & UVC_STREAM_ERR) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"Marking buffer as bad (error bit set).\n"); "Marking buffer as bad (error bit set)\n");
buf->error = 1; 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 (buf->state != UVC_BUF_STATE_ACTIVE) {
if (fid == stream->last_fid) { if (fid == stream->last_fid) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"Dropping payload (out of sync).\n"); "Dropping payload (out of sync)\n");
if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) && if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
(data[1] & UVC_STREAM_EOF)) (data[1] & UVC_STREAM_EOF))
stream->last_fid ^= UVC_STREAM_FID; 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. * previous payload had the EOF bit set.
*/ */
if (fid != stream->last_fid && buf->bytesused != 0) { if (fid != stream->last_fid && buf->bytesused != 0) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"Frame complete (FID bit toggled).\n"); "Frame complete (FID bit toggled)\n");
buf->state = UVC_BUF_STATE_READY; buf->state = UVC_BUF_STATE_READY;
return -EAGAIN; 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. */ /* Complete the current frame if the buffer size was exceeded. */
if (len > maxlen) { if (len > maxlen) {
uvc_trace(uvc_urb->stream->dev, UVC_TRACE_FRAME, uvc_dbg(uvc_urb->stream->dev, FRAME,
"Frame complete (overflow).\n"); "Frame complete (overflow)\n");
buf->error = 1; buf->error = 1;
buf->state = UVC_BUF_STATE_READY; 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. */ /* Mark the buffer as done if the EOF marker is set. */
if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) { if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME, "Frame complete (EOF found)\n");
"Frame complete (EOF found).\n");
if (data[0] == len) if (data[0] == len)
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME, "EOF in empty payload\n");
"EOF in empty payload.\n");
buf->state = UVC_BUF_STATE_READY; buf->state = UVC_BUF_STATE_READY;
if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
stream->last_fid ^= UVC_STREAM_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); memcpy(&meta->length, mem, length);
meta_buf->bytesused += length + sizeof(meta->ns) + sizeof(meta->sof); meta_buf->bytesused += length + sizeof(meta->ns) + sizeof(meta->sof);
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"%s(): t-sys %lluns, SOF %u, len %u, flags 0x%x, PTS %u, STC %u frame SOF %u\n", "%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, __func__, ktime_to_ns(time), meta->sof, meta->length,
meta->flags, meta->flags,
has_pts ? *(u32 *)meta->buf : 0, has_pts ? *(u32 *)meta->buf : 0,
has_scr ? *(u32 *)scr : 0, has_scr ? *(u32 *)scr : 0,
has_scr ? *(u32 *)(scr + 4) & 0x7ff : 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) { for (i = 0; i < urb->number_of_packets; ++i) {
if (urb->iso_frame_desc[i].status < 0) { if (urb->iso_frame_desc[i].status < 0) {
uvc_trace(stream->dev, UVC_TRACE_FRAME, uvc_dbg(stream->dev, FRAME,
"USB isochronous frame lost (%d).\n", "USB isochronous frame lost (%d)\n",
urb->iso_frame_desc[i].status); urb->iso_frame_desc[i].status);
/* Mark the buffer as faulty. */ /* Mark the buffer as faulty. */
if (buf != NULL) if (buf != NULL)
buf->error = 1; buf->error = 1;
@ -1631,16 +1629,16 @@ static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
} }
if (i == UVC_URBS) { if (i == UVC_URBS) {
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"Allocated %u URB buffers of %ux%u bytes each.\n", "Allocated %u URB buffers of %ux%u bytes each\n",
UVC_URBS, npackets, psize); UVC_URBS, npackets, psize);
return npackets; return npackets;
} }
} }
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"Failed to allocate URB buffers (%u bytes per packet).\n", "Failed to allocate URB buffers (%u bytes per packet)\n",
psize); psize);
return 0; return 0;
} }
@ -1839,13 +1837,13 @@ static int uvc_video_start_transfer(struct uvc_streaming *stream,
bandwidth = stream->ctrl.dwMaxPayloadTransferSize; bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
if (bandwidth == 0) { if (bandwidth == 0) {
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"Device requested null bandwidth, defaulting to lowest.\n"); "Device requested null bandwidth, defaulting to lowest\n");
bandwidth = 1; bandwidth = 1;
} else { } else {
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"Device requested %u B/frame bandwidth.\n", "Device requested %u B/frame bandwidth\n",
bandwidth); bandwidth);
} }
for (i = 0; i < intf->num_altsetting; ++i) { 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) { if (best_ep == NULL) {
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"No fast enough alt setting for requested bandwidth.\n"); "No fast enough alt setting for requested bandwidth\n");
return -EIO; return -EIO;
} }
uvc_trace(stream->dev, UVC_TRACE_VIDEO, uvc_dbg(stream->dev, VIDEO,
"Selecting alternate setting %u (%u B/frame bandwidth).\n", "Selecting alternate setting %u (%u B/frame bandwidth)\n",
altsetting, best_psize); altsetting, best_psize);
ret = usb_set_interface(stream->dev->udev, intfnum, altsetting); ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
if (ret < 0) if (ret < 0)

34
drivers/media/usb/uvc/uvcvideo.h
Просмотреть файл

@ -729,18 +729,18 @@ struct uvc_driver {
* Debugging, printing and logging * Debugging, printing and logging
*/ */
#define UVC_TRACE_PROBE (1 << 0) #define UVC_DBG_PROBE (1 << 0)
#define UVC_TRACE_DESCR (1 << 1) #define UVC_DBG_DESCR (1 << 1)
#define UVC_TRACE_CONTROL (1 << 2) #define UVC_DBG_CONTROL (1 << 2)
#define UVC_TRACE_FORMAT (1 << 3) #define UVC_DBG_FORMAT (1 << 3)
#define UVC_TRACE_CAPTURE (1 << 4) #define UVC_DBG_CAPTURE (1 << 4)
#define UVC_TRACE_CALLS (1 << 5) #define UVC_DBG_CALLS (1 << 5)
#define UVC_TRACE_FRAME (1 << 7) #define UVC_DBG_FRAME (1 << 7)
#define UVC_TRACE_SUSPEND (1 << 8) #define UVC_DBG_SUSPEND (1 << 8)
#define UVC_TRACE_STATUS (1 << 9) #define UVC_DBG_STATUS (1 << 9)
#define UVC_TRACE_VIDEO (1 << 10) #define UVC_DBG_VIDEO (1 << 10)
#define UVC_TRACE_STATS (1 << 11) #define UVC_DBG_STATS (1 << 11)
#define UVC_TRACE_CLOCK (1 << 12) #define UVC_DBG_CLOCK (1 << 12)
#define UVC_WARN_MINMAX 0 #define UVC_WARN_MINMAX 0
#define UVC_WARN_PROBE_DEF 1 #define UVC_WARN_PROBE_DEF 1
@ -748,20 +748,20 @@ struct uvc_driver {
extern unsigned int uvc_clock_param; extern unsigned int uvc_clock_param;
extern unsigned int uvc_no_drop_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_timeout_param;
extern unsigned int uvc_hw_timestamps_param; extern unsigned int uvc_hw_timestamps_param;
#define uvc_trace(_dev, flag, fmt, ...) \ #define uvc_dbg(_dev, flag, fmt, ...) \
do { \ do { \
if (uvc_trace_param & flag) \ if (uvc_dbg_param & UVC_DBG_##flag) \
dev_printk(KERN_DEBUG, &(_dev)->udev->dev, fmt, \ dev_printk(KERN_DEBUG, &(_dev)->udev->dev, fmt, \
##__VA_ARGS__); \ ##__VA_ARGS__); \
} while (0) } while (0)
#define uvc_trace_cont(flag, fmt, ...) \ #define uvc_dbg_cont(flag, fmt, ...) \
do { \ do { \
if (uvc_trace_param & flag) \ if (uvc_dbg_param & UVC_DBG_##flag) \
pr_cont(fmt, ##__VA_ARGS__); \ pr_cont(fmt, ##__VA_ARGS__); \
} while (0) } while (0)