Lines Matching defs:usbvision
2 * usbvision-core.c - driver for NT100x USB video capture devices
8 * This module is part of usbvision driver project.
46 #include "usbvision.h"
106 static int usbvision_request_intra(struct usb_usbvision *usbvision);
107 static int usbvision_unrequest_intra(struct usb_usbvision *usbvision);
108 static int usbvision_adjust_compression(struct usb_usbvision *usbvision);
109 static int usbvision_measure_bandwidth(struct usb_usbvision *usbvision);
182 static int scratch_len(struct usb_usbvision *usbvision) /* This returns the amount of data actually in the buffer */
184 int len = usbvision->scratch_write_ptr - usbvision->scratch_read_ptr;
195 static int scratch_free(struct usb_usbvision *usbvision)
197 int free = usbvision->scratch_read_ptr - usbvision->scratch_write_ptr;
211 static int scratch_put(struct usb_usbvision *usbvision, unsigned char *data,
216 if (usbvision->scratch_write_ptr + len < scratch_buf_size) {
217 memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len);
218 usbvision->scratch_write_ptr += len;
220 len_part = scratch_buf_size - usbvision->scratch_write_ptr;
221 memcpy(usbvision->scratch + usbvision->scratch_write_ptr, data, len_part);
223 usbvision->scratch_write_ptr = 0; /* just set write_ptr to zero */
225 memcpy(usbvision->scratch, data + len_part, len - len_part);
226 usbvision->scratch_write_ptr = len - len_part;
230 PDEBUG(DBG_SCRATCH, "len=%d, new write_ptr=%d\n", len, usbvision->scratch_write_ptr);
236 static void scratch_mark_header(struct usb_usbvision *usbvision)
238 PDEBUG(DBG_SCRATCH, "header at write_ptr=%d\n", usbvision->scratch_headermarker_write_ptr);
240 usbvision->scratch_headermarker[usbvision->scratch_headermarker_write_ptr] =
241 usbvision->scratch_write_ptr;
242 usbvision->scratch_headermarker_write_ptr += 1;
243 usbvision->scratch_headermarker_write_ptr %= USBVISION_NUM_HEADERMARKER;
247 static int scratch_get_extra(struct usb_usbvision *usbvision,
253 memcpy(data, usbvision->scratch + *ptr, len);
257 memcpy(data, usbvision->scratch + *ptr, len_part);
261 memcpy(data + len_part, usbvision->scratch, len - len_part);
273 static void scratch_set_extra_ptr(struct usb_usbvision *usbvision, int *ptr,
276 *ptr = (usbvision->scratch_read_ptr + len) % scratch_buf_size;
292 static int scratch_get(struct usb_usbvision *usbvision, unsigned char *data,
297 if (usbvision->scratch_read_ptr + len < scratch_buf_size) {
298 memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len);
299 usbvision->scratch_read_ptr += len;
301 len_part = scratch_buf_size - usbvision->scratch_read_ptr;
302 memcpy(data, usbvision->scratch + usbvision->scratch_read_ptr, len_part);
304 usbvision->scratch_read_ptr = 0; /* just set the read_ptr to zero */
306 memcpy(data + len_part, usbvision->scratch, len - len_part);
307 usbvision->scratch_read_ptr = len - len_part;
311 PDEBUG(DBG_SCRATCH, "len=%d, new read_ptr=%d\n", len, usbvision->scratch_read_ptr);
318 static int scratch_get_header(struct usb_usbvision *usbvision,
323 PDEBUG(DBG_SCRATCH, "from read_ptr=%d", usbvision->scratch_headermarker_read_ptr);
325 while (usbvision->scratch_headermarker_write_ptr -
326 usbvision->scratch_headermarker_read_ptr != 0) {
327 usbvision->scratch_read_ptr =
328 usbvision->scratch_headermarker[usbvision->scratch_headermarker_read_ptr];
329 usbvision->scratch_headermarker_read_ptr += 1;
330 usbvision->scratch_headermarker_read_ptr %= USBVISION_NUM_HEADERMARKER;
331 scratch_get(usbvision, (unsigned char *)header, USBVISION_HEADER_LENGTH);
347 static void scratch_rm_old(struct usb_usbvision *usbvision, int len)
349 usbvision->scratch_read_ptr += len;
350 usbvision->scratch_read_ptr %= scratch_buf_size;
351 PDEBUG(DBG_SCRATCH, "read_ptr is now %d\n", usbvision->scratch_read_ptr);
356 static void scratch_reset(struct usb_usbvision *usbvision)
360 usbvision->scratch_read_ptr = 0;
361 usbvision->scratch_write_ptr = 0;
362 usbvision->scratch_headermarker_read_ptr = 0;
363 usbvision->scratch_headermarker_write_ptr = 0;
364 usbvision->isocstate = isoc_state_no_frame;
367 int usbvision_scratch_alloc(struct usb_usbvision *usbvision)
369 usbvision->scratch = vmalloc_32(scratch_buf_size);
370 scratch_reset(usbvision);
371 if (usbvision->scratch == NULL) {
372 dev_err(&usbvision->dev->dev,
380 void usbvision_scratch_free(struct usb_usbvision *usbvision)
382 vfree(usbvision->scratch);
383 usbvision->scratch = NULL;
391 int usbvision_decompress_alloc(struct usb_usbvision *usbvision)
395 usbvision->intra_frame_buffer = vmalloc_32(IFB_size);
396 if (usbvision->intra_frame_buffer == NULL) {
397 dev_err(&usbvision->dev->dev,
410 void usbvision_decompress_free(struct usb_usbvision *usbvision)
412 vfree(usbvision->intra_frame_buffer);
413 usbvision->intra_frame_buffer = NULL;
425 static enum parse_state usbvision_find_header(struct usb_usbvision *usbvision)
430 frame = usbvision->cur_frame;
432 while (scratch_get_header(usbvision, &frame->isoc_header) == USBVISION_HEADER_LENGTH) {
446 if (usbvision->request_intra) {
449 usbvision->last_isoc_frame_num = -1; /* do not check for lost frames this time */
450 usbvision_unrequest_intra(usbvision);
460 frame->frmwidth = frame->isoc_header.frame_width * usbvision->stretch_width;
461 frame->frmheight = frame->isoc_header.frame_height * usbvision->stretch_height;
465 scratch_reset(usbvision);
472 if (usbvision->last_isoc_frame_num >= 0) {
473 if (((usbvision->last_isoc_frame_num + 1) % 32) != frame->isoc_header.frame_num) {
476 usbvision_request_intra(usbvision);
480 usbvision->last_isoc_frame_num = frame->isoc_header.frame_num;
482 usbvision->header_count++;
489 static enum parse_state usbvision_parse_lines_422(struct usb_usbvision *usbvision,
501 frame = usbvision->cur_frame;
506 if (scratch_len(usbvision) < len) {
515 stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
517 clipmask_add = usbvision->stretch_width;
519 for (i = 0; i < frame->frmwidth; i += (2 * usbvision->stretch_width)) {
520 scratch_get(usbvision, &yuyv[0], 4);
591 frame->curline += usbvision->stretch_height;
592 *pcopylen += frame->v4l2_linesize * usbvision->stretch_height;
600 static int usbvision_decompress(struct usb_usbvision *usbvision, unsigned char *compressed,
629 usbvision->compr_block_types[block_type]++;
692 static enum parse_state usbvision_parse_compress(struct usb_usbvision *usbvision,
709 frame = usbvision->cur_frame;
730 usbvision_adjust_compression(usbvision);
732 if (scratch_len(usbvision) < USBVISION_STRIP_HEADER_LEN)
736 scratch_set_extra_ptr(usbvision, &strip_ptr, 0);
737 scratch_get_extra(usbvision, &strip_header[0], &strip_ptr,
742 usbvision->strip_magic_errors++;
748 usbvision->strip_line_number_errors++;
755 usbvision_request_intra(usbvision);
758 if (scratch_len(usbvision) < strip_len) {
763 if (usbvision->intra_frame_buffer) {
764 Y = usbvision->intra_frame_buffer + frame->frmwidth * frame->curline;
765 U = usbvision->intra_frame_buffer + image_size + (frame->frmwidth / 2) * (frame->curline / 2);
766 V = usbvision->intra_frame_buffer + image_size / 4 * 5 + (frame->frmwidth / 2) * (frame->curline / 2);
773 scratch_get(usbvision, strip_data, strip_len);
780 usbvision->block_pos = block_pos;
782 usbvision_decompress(usbvision, strip_data, Y, &block_pos, &block_type_pos, idx_end);
783 if (strip_len > usbvision->max_strip_len)
784 usbvision->max_strip_len = strip_len;
787 usbvision_decompress(usbvision, strip_data, V, &block_pos, &block_type_pos, idx_end / 2);
789 usbvision_decompress(usbvision, strip_data, U, &block_pos, &block_type_pos, idx_end / 2);
791 if (block_pos > usbvision->comprblock_pos)
792 usbvision->comprblock_pos = block_pos;
794 usbvision->strip_len_errors++;
870 static enum parse_state usbvision_parse_lines_420(struct usb_usbvision *usbvision,
890 frame = usbvision->cur_frame;
892 f_odd = f_even + frame->v4l2_linesize * usbvision->stretch_height;
895 /* In this mode usbvision transfer 3 bytes for every 2 pixels */
898 stretch_bytes = (usbvision->stretch_width - 1) * bytes_per_pixel;
901 clipmask_add = usbvision->stretch_width;
904 if (scratch_len(usbvision) < (int)pixel_per_line * 3) {
917 scratch_set_extra_ptr(usbvision, &y_ptr, y_odd_offset);
918 scratch_set_extra_ptr(usbvision, &u_ptr, y_block_size);
919 scratch_set_extra_ptr(usbvision, &v_ptr, y_odd_offset
924 scratch_get(usbvision, &y[0], 2);
925 scratch_get_extra(usbvision, &u, &u_ptr, 1);
926 scratch_get_extra(usbvision, &v, &v_ptr, 1);
1021 scratch_get_extra(usbvision, &y[0], &y_ptr, 2);
1110 scratch_rm_old(usbvision, y_step[block % y_step_size] * sub_block_size);
1119 scratch_rm_old(usbvision, pixel_per_line * 3 / 2
1122 frame->curline += 2 * usbvision->stretch_height;
1123 *pcopylen += frame->v4l2_linesize * 2 * usbvision->stretch_height;
1138 static void usbvision_parse_data(struct usb_usbvision *usbvision)
1145 frame = usbvision->cur_frame;
1147 PDEBUG(DBG_PARSE, "parsing len=%d\n", scratch_len(usbvision));
1151 if (scratch_len(usbvision)) {
1153 newstate = usbvision_find_header(usbvision);
1155 if (usbvision->isoc_mode == ISOC_MODE_YUV420)
1156 newstate = usbvision_parse_lines_420(usbvision, ©len);
1157 else if (usbvision->isoc_mode == ISOC_MODE_YUV422)
1158 newstate = usbvision_parse_lines_422(usbvision, ©len);
1159 else if (usbvision->isoc_mode == ISOC_MODE_COMPRESS)
1160 newstate = usbvision_parse_compress(usbvision, ©len);
1173 frame->sequence = usbvision->frame_num;
1175 spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
1176 list_move_tail(&(frame->frame), &usbvision->outqueue);
1177 usbvision->cur_frame = NULL;
1178 spin_unlock_irqrestore(&usbvision->queue_lock, lock_flags);
1180 usbvision->frame_num++;
1183 if (waitqueue_active(&usbvision->wait_frame)) {
1185 wake_up_interruptible(&usbvision->wait_frame);
1199 static int usbvision_compress_isochronous(struct usb_usbvision *usbvision,
1214 usbvision->isoc_err_count++;
1221 usbvision->isoc_skip_count++;
1225 usbvision->isocstate = isoc_state_no_frame;
1226 usbvision->isoc_skip_count++;
1228 } else if (packet_len > usbvision->isoc_packet_size) {
1230 usbvision->isoc_skip_count++;
1236 if (usbvision->isocstate == isoc_state_no_frame) { /* new frame begins */
1237 usbvision->isocstate = isoc_state_in_frame;
1238 scratch_mark_header(usbvision);
1239 usbvision_measure_bandwidth(usbvision);
1244 * If usbvision continues to feed us with data but there is no
1251 if (scratch_free(usbvision) < packet_len) {
1252 usbvision->scratch_ovf_count++;
1254 scratch_len(usbvision), packet_len);
1255 scratch_rm_old(usbvision, packet_len - scratch_free(usbvision));
1259 scratch_put(usbvision, packet_data, packet_len);
1261 usbvision->isoc_data_count += packet_len;
1262 usbvision->isoc_packet_count++;
1269 printk(KERN_DEBUG "+%d.\n", usbvision->scratchlen);
1282 struct usb_usbvision *usbvision = urb->context;
1288 if (!USBVISION_IS_OPERATIONAL(usbvision))
1295 f = &usbvision->cur_frame;
1298 if (usbvision->streaming == stream_interrupt) {
1299 usbvision->streaming = stream_idle;
1305 wake_up_interruptible(&usbvision->wait_stream);
1309 len = usbvision_compress_isochronous(usbvision, urb);
1311 usbvision->isoc_urb_count++;
1312 usbvision->urb_length = len;
1314 if (usbvision->streaming == stream_on) {
1316 if (scratch_len(usbvision) > USBVISION_HEADER_LENGTH &&
1317 !list_empty(&(usbvision->inqueue))) {
1319 (*f) = list_entry(usbvision->inqueue.next,
1323 usbvision_parse_data(usbvision);
1329 scratch_reset(usbvision);
1333 scratch_reset(usbvision);
1336 usbvision->time_in_irq += jiffies - start_time;
1344 urb->dev = usbvision->dev;
1348 dev_err(&usbvision->dev->dev,
1357 /* Low level usbvision access functions */
1367 int usbvision_read_reg(struct usb_usbvision *usbvision, unsigned char reg)
1372 if (!USBVISION_IS_OPERATIONAL(usbvision))
1375 err_code = usb_control_msg(usbvision->dev, usb_rcvctrlpipe(usbvision->dev, 1),
1381 dev_err(&usbvision->dev->dev,
1392 * 0 -> usbvision is not yet ready
1396 int usbvision_write_reg(struct usb_usbvision *usbvision, unsigned char reg,
1401 if (!USBVISION_IS_OPERATIONAL(usbvision))
1404 err_code = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
1410 dev_err(&usbvision->dev->dev,
1419 struct usb_usbvision *usbvision = (struct usb_usbvision *)urb->context;
1422 usbvision->ctrl_urb_busy = 0;
1423 if (waitqueue_active(&usbvision->ctrl_urb_wq))
1424 wake_up_interruptible(&usbvision->ctrl_urb_wq);
1428 static int usbvision_write_reg_irq(struct usb_usbvision *usbvision, int address,
1436 if (usbvision->ctrl_urb_busy)
1438 usbvision->ctrl_urb_busy = 1;
1440 usbvision->ctrl_urb_setup.bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT;
1441 usbvision->ctrl_urb_setup.bRequest = USBVISION_OP_CODE;
1442 usbvision->ctrl_urb_setup.wValue = 0;
1443 usbvision->ctrl_urb_setup.wIndex = cpu_to_le16(address);
1444 usbvision->ctrl_urb_setup.wLength = cpu_to_le16(len);
1445 usb_fill_control_urb(usbvision->ctrl_urb, usbvision->dev,
1446 usb_sndctrlpipe(usbvision->dev, 1),
1447 (unsigned char *)&usbvision->ctrl_urb_setup,
1448 (void *)usbvision->ctrl_urb_buffer, len,
1450 (void *)usbvision);
1452 memcpy(usbvision->ctrl_urb_buffer, data, len);
1454 err_code = usb_submit_urb(usbvision->ctrl_urb, GFP_ATOMIC);
1457 usbvision->ctrl_urb_busy = 0;
1464 static int usbvision_init_compression(struct usb_usbvision *usbvision)
1466 usbvision->last_isoc_frame_num = -1;
1467 usbvision->isoc_data_count = 0;
1468 usbvision->isoc_packet_count = 0;
1469 usbvision->isoc_skip_count = 0;
1470 usbvision->compr_level = 50;
1471 usbvision->last_compr_level = -1;
1472 usbvision->isoc_urb_count = 0;
1473 usbvision->request_intra = 1;
1474 usbvision->isoc_measure_bandwidth_count = 0;
1483 static int usbvision_measure_bandwidth(struct usb_usbvision *usbvision)
1485 if (usbvision->isoc_measure_bandwidth_count < 2) { /* this gives an average bandwidth of 3 frames */
1486 usbvision->isoc_measure_bandwidth_count++;
1489 if ((usbvision->isoc_packet_size > 0) && (usbvision->isoc_packet_count > 0)) {
1490 usbvision->used_bandwidth = usbvision->isoc_data_count /
1491 (usbvision->isoc_packet_count + usbvision->isoc_skip_count) *
1492 100 / usbvision->isoc_packet_size;
1494 usbvision->isoc_measure_bandwidth_count = 0;
1495 usbvision->isoc_data_count = 0;
1496 usbvision->isoc_packet_count = 0;
1497 usbvision->isoc_skip_count = 0;
1501 static int usbvision_adjust_compression(struct usb_usbvision *usbvision)
1507 if ((adjust_compression) && (usbvision->used_bandwidth > 0)) {
1508 usbvision->compr_level += (usbvision->used_bandwidth - 90) / 2;
1509 RESTRICT_TO_RANGE(usbvision->compr_level, 0, 100);
1510 if (usbvision->compr_level != usbvision->last_compr_level) {
1513 if (usbvision->bridge_type == BRIDGE_NT1004 || usbvision->bridge_type == BRIDGE_NT1005) {
1514 buffer[0] = (unsigned char)(4 + 16 * usbvision->compr_level / 100); /* PCM Threshold 1 */
1515 buffer[1] = (unsigned char)(4 + 8 * usbvision->compr_level / 100); /* PCM Threshold 2 */
1516 distortion = 7 + 248 * usbvision->compr_level / 100;
1519 distortion = 1 + 42 * usbvision->compr_level / 100;
1523 buffer[0] = (unsigned char)(4 + 16 * usbvision->compr_level / 100); /* PCM threshold 1 */
1524 buffer[1] = (unsigned char)(4 + 8 * usbvision->compr_level / 100); /* PCM threshold 2 */
1525 distortion = 2 + 253 * usbvision->compr_level / 100;
1528 distortion = 0 + 43 * usbvision->compr_level / 100;
1532 err_code = usbvision_write_reg_irq(usbvision, USBVISION_PCM_THR1, buffer, 6);
1536 usbvision->last_compr_level = usbvision->compr_level;
1543 static int usbvision_request_intra(struct usb_usbvision *usbvision)
1548 usbvision->request_intra = 1;
1550 usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
1554 static int usbvision_unrequest_intra(struct usb_usbvision *usbvision)
1559 usbvision->request_intra = 0;
1561 usbvision_write_reg_irq(usbvision, USBVISION_FORCE_INTRA, buffer, 1);
1566 * usbvision utility functions
1569 int usbvision_power_off(struct usb_usbvision *usbvision)
1575 err_code = usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
1577 usbvision->power = 0;
1583 static int usbvision_init_webcam(struct usb_usbvision *usbvision)
1602 if (usbvision_device_data[usbvision->dev_model].video_norm == V4L2_STD_NTSC)
1606 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SOFT);
1608 rc = usb_control_msg(usbvision->dev,
1609 usb_sndctrlpipe(usbvision->dev, 1),
1617 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SIO);
1619 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 3 | 0x10);
1620 usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, 0);
1621 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SOFT);
1622 usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, USBVISION_IO_2);
1623 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SOFT | USBVISION_CLK_OUT);
1624 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SOFT | USBVISION_DAT_IO);
1625 usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_SER_MODE_SOFT | USBVISION_CLK_OUT | USBVISION_DAT_IO);
1635 static int usbvision_set_video_format(struct usb_usbvision *usbvision, int format)
1641 if (!USBVISION_IS_OPERATIONAL(usbvision))
1649 printk(KERN_ERR "usbvision: unknown video format %02x, using default YUV420",
1655 rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
1665 usbvision->isoc_mode = format;
1674 int usbvision_set_output(struct usb_usbvision *usbvision, int width,
1682 if (!USBVISION_IS_OPERATIONAL(usbvision))
1687 usbvision->stretch_width = 2;
1690 usbvision->stretch_width = 1;
1695 usbvision->stretch_height = 2;
1698 usbvision->stretch_height = 1;
1708 usbvision->stretch_width, usbvision->stretch_height);
1711 if ((usb_width != usbvision->curwidth) || (usb_height != usbvision->curheight)) {
1717 err_code = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
1723 dev_err(&usbvision->dev->dev,
1727 usbvision->curwidth = usbvision->stretch_width * usb_width;
1728 usbvision->curheight = usbvision->stretch_height * usb_height;
1731 if (usbvision->isoc_mode == ISOC_MODE_YUV422)
1732 frame_rate = (usbvision->isoc_packet_size * 1000) / (usb_width * usb_height * 2);
1733 else if (usbvision->isoc_mode == ISOC_MODE_YUV420)
1734 frame_rate = (usbvision->isoc_packet_size * 1000) / ((usb_width * usb_height * 12) / 8);
1738 if (usbvision->tvnorm_id & V4L2_STD_625_50)
1740 else if (usbvision->tvnorm_id & V4L2_STD_525_60)
1749 if (usbvision_device_data[usbvision->dev_model].codec == CODEC_WEBCAM) {
1750 if (usbvision_device_data[usbvision->dev_model].video_norm == V4L2_STD_PAL)
1764 err_code = usbvision_write_reg(usbvision, USBVISION_FRM_RATE, frame_drop);
1773 int usbvision_frames_alloc(struct usb_usbvision *usbvision, int number_of_frames)
1778 usbvision->max_frame_size = PAGE_ALIGN(usbvision->curwidth *
1779 usbvision->curheight *
1780 usbvision->palette.bytes_per_pixel);
1783 usbvision->num_frames = number_of_frames;
1784 while (usbvision->num_frames > 0) {
1785 usbvision->fbuf_size = usbvision->num_frames * usbvision->max_frame_size;
1786 usbvision->fbuf = usbvision_rvmalloc(usbvision->fbuf_size);
1787 if (usbvision->fbuf)
1789 usbvision->num_frames--;
1792 spin_lock_init(&usbvision->queue_lock);
1793 init_waitqueue_head(&usbvision->wait_frame);
1794 init_waitqueue_head(&usbvision->wait_stream);
1797 for (i = 0; i < usbvision->num_frames; i++) {
1798 usbvision->frame[i].index = i;
1799 usbvision->frame[i].grabstate = frame_state_unused;
1800 usbvision->frame[i].data = usbvision->fbuf +
1801 i * usbvision->max_frame_size;
1805 usbvision->stretch_width = 1;
1806 usbvision->stretch_height = 1;
1807 usbvision->frame[i].width = usbvision->curwidth;
1808 usbvision->frame[i].height = usbvision->curheight;
1809 usbvision->frame[i].bytes_read = 0;
1812 usbvision->num_frames, usbvision->max_frame_size);
1813 return usbvision->num_frames;
1820 void usbvision_frames_free(struct usb_usbvision *usbvision)
1823 PDEBUG(DBG_FUNC, "free %d frames", usbvision->num_frames);
1825 if (usbvision->fbuf != NULL) {
1826 usbvision_rvfree(usbvision->fbuf, usbvision->fbuf_size);
1827 usbvision->fbuf = NULL;
1829 usbvision->num_frames = 0;
1836 void usbvision_empty_framequeues(struct usb_usbvision *usbvision)
1840 INIT_LIST_HEAD(&(usbvision->inqueue));
1841 INIT_LIST_HEAD(&(usbvision->outqueue));
1844 usbvision->frame[i].grabstate = frame_state_unused;
1845 usbvision->frame[i].bytes_read = 0;
1853 int usbvision_stream_interrupt(struct usb_usbvision *usbvision)
1859 usbvision->streaming = stream_interrupt;
1860 ret = wait_event_timeout(usbvision->wait_stream,
1861 (usbvision->streaming == stream_idle),
1871 static int usbvision_set_compress_params(struct usb_usbvision *usbvision)
1890 if (!USBVISION_IS_OPERATIONAL(usbvision))
1893 rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
1905 if (usbvision->bridge_type == BRIDGE_NT1004) {
1921 if (!USBVISION_IS_OPERATIONAL(usbvision))
1924 rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
1945 int usbvision_set_input(struct usb_usbvision *usbvision)
1952 if (!USBVISION_IS_OPERATIONAL(usbvision))
1956 if (usbvision_device_data[usbvision->dev_model].vin_reg1_override) {
1957 value[0] = usbvision_device_data[usbvision->dev_model].vin_reg1;
1958 } else if (usbvision_device_data[usbvision->dev_model].codec == CODEC_SAA7113) {
1968 rc = usbvision_write_reg(usbvision, USBVISION_VIN_REG1, value[0]);
1976 if (usbvision->tvnorm_id & V4L2_STD_PAL) {
1985 } else if (usbvision->tvnorm_id & V4L2_STD_SECAM) {
2006 if (usbvision_device_data[usbvision->dev_model].codec == CODEC_WEBCAM) {
2011 if (usbvision_device_data[usbvision->dev_model].x_offset >= 0) {
2012 value[4] = usbvision_device_data[usbvision->dev_model].x_offset & 0xff;
2013 value[5] = (usbvision_device_data[usbvision->dev_model].x_offset & 0x0300) >> 8;
2021 if (usbvision_device_data[usbvision->dev_model].y_offset >= 0) {
2022 value[6] = usbvision_device_data[usbvision->dev_model].y_offset & 0xff;
2023 value[7] = (usbvision_device_data[usbvision->dev_model].y_offset & 0x0300) >> 8;
2031 rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
2044 if (usbvision_device_data[usbvision->dev_model].dvi_yuv_override) {
2045 dvi_yuv_value = usbvision_device_data[usbvision->dev_model].dvi_yuv;
2046 } else if (usbvision_device_data[usbvision->dev_model].codec == CODEC_SAA7113) {
2051 return usbvision_write_reg(usbvision, USBVISION_DVI_YUV, dvi_yuv_value);
2058 * Set the buffer address needed by the usbvision dram to operate
2063 static int usbvision_set_dram_settings(struct usb_usbvision *usbvision)
2068 if (usbvision->isoc_mode == ISOC_MODE_COMPRESS) {
2103 if (!USBVISION_IS_OPERATIONAL(usbvision))
2106 rc = usb_control_msg(usbvision->dev, usb_sndctrlpipe(usbvision->dev, 1),
2113 dev_err(&usbvision->dev->dev, "%s: ERROR=%d\n", __func__, rc);
2118 rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, USBVISION_RES_UR |
2122 rc = usbvision_write_reg(usbvision, USBVISION_DRM_CONT, 0x00);
2135 int usbvision_power_on(struct usb_usbvision *usbvision)
2141 usbvision_write_reg(usbvision, USBVISION_PWR_REG, USBVISION_SSPND_EN);
2142 usbvision_write_reg(usbvision, USBVISION_PWR_REG,
2145 if (usbvision_device_data[usbvision->dev_model].codec == CODEC_WEBCAM) {
2146 usbvision_write_reg(usbvision, USBVISION_VIN_REG1,
2148 usbvision_write_reg(usbvision, USBVISION_VIN_REG2,
2151 usbvision_write_reg(usbvision, USBVISION_PWR_REG,
2154 err_code = usbvision_write_reg(usbvision, USBVISION_PWR_REG,
2157 usbvision->power = 1;
2164 * usbvision timer stuff
2170 struct usb_usbvision *usbvision = container_of(work, struct usb_usbvision, power_off_work);
2173 if (mutex_lock_interruptible(&usbvision->v4l2_lock))
2176 if (usbvision->user == 0) {
2177 usbvision_i2c_unregister(usbvision);
2179 usbvision_power_off(usbvision);
2180 usbvision->initialized = 0;
2182 mutex_unlock(&usbvision->v4l2_lock);
2187 struct usb_usbvision *usbvision = (void *)data;
2190 del_timer(&usbvision->power_off_timer);
2191 INIT_WORK(&usbvision->power_off_work, call_usbvision_power_off);
2192 (void) schedule_work(&usbvision->power_off_work);
2195 void usbvision_init_power_off_timer(struct usb_usbvision *usbvision)
2197 init_timer(&usbvision->power_off_timer);
2198 usbvision->power_off_timer.data = (long)usbvision;
2199 usbvision->power_off_timer.function = usbvision_power_off_timer;
2202 void usbvision_set_power_off_timer(struct usb_usbvision *usbvision)
2204 mod_timer(&usbvision->power_off_timer, jiffies + USBVISION_POWEROFF_TIME);
2207 void usbvision_reset_power_off_timer(struct usb_usbvision *usbvision)
2209 if (timer_pending(&usbvision->power_off_timer))
2210 del_timer(&usbvision->power_off_timer);
2218 int usbvision_begin_streaming(struct usb_usbvision *usbvision)
2220 if (usbvision->isoc_mode == ISOC_MODE_COMPRESS)
2221 usbvision_init_compression(usbvision);
2222 return usbvision_write_reg(usbvision, USBVISION_VIN_REG2,
2223 USBVISION_NOHVALID | usbvision->vin_reg2_preset);
2231 int usbvision_restart_isoc(struct usb_usbvision *usbvision)
2235 ret = usbvision_write_reg(usbvision, USBVISION_PWR_REG,
2239 ret = usbvision_write_reg(usbvision, USBVISION_PWR_REG,
2244 ret = usbvision_write_reg(usbvision, USBVISION_VIN_REG2,
2246 usbvision->vin_reg2_preset);
2251 while ((usbvision_read_reg(usbvision, USBVISION_STATUS_REG) & 0x01) != 1)
2257 int usbvision_audio_off(struct usb_usbvision *usbvision)
2259 if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, USBVISION_AUDIO_MUTE) < 0) {
2263 usbvision->audio_mute = 0;
2264 usbvision->audio_channel = USBVISION_AUDIO_MUTE;
2268 int usbvision_set_audio(struct usb_usbvision *usbvision, int audio_channel)
2270 if (!usbvision->audio_mute) {
2271 if (usbvision_write_reg(usbvision, USBVISION_IOPIN_REG, audio_channel) < 0) {
2276 usbvision->audio_channel = audio_channel;
2280 int usbvision_setup(struct usb_usbvision *usbvision, int format)
2282 if (usbvision_device_data[usbvision->dev_model].codec == CODEC_WEBCAM)
2283 usbvision_init_webcam(usbvision);
2284 usbvision_set_video_format(usbvision, format);
2285 usbvision_set_dram_settings(usbvision);
2286 usbvision_set_compress_params(usbvision);
2287 usbvision_set_input(usbvision);
2288 usbvision_set_output(usbvision, MAX_USB_WIDTH, MAX_USB_HEIGHT);
2289 usbvision_restart_isoc(usbvision);
2292 return USBVISION_IS_OPERATIONAL(usbvision);
2327 int usbvision_init_isoc(struct usb_usbvision *usbvision)
2329 struct usb_device *dev = usbvision->dev;
2333 if (!USBVISION_IS_OPERATIONAL(usbvision))
2336 usbvision->cur_frame = NULL;
2337 scratch_reset(usbvision);
2340 err_code = usbvision_set_alternate(usbvision);
2342 usbvision->last_error = err_code;
2345 sb_size = USBVISION_URB_FRAMES * usbvision->isoc_packet_size;
2347 reg_value = (16 - usbvision_read_reg(usbvision,
2350 usbvision->usb_bandwidth = reg_value >> 1;
2352 usbvision->usb_bandwidth);
2364 dev_err(&usbvision->dev->dev,
2368 usbvision->sbuf[buf_idx].urb = urb;
2369 usbvision->sbuf[buf_idx].data =
2370 usb_alloc_coherent(usbvision->dev,
2375 urb->context = usbvision;
2376 urb->pipe = usb_rcvisocpipe(dev, usbvision->video_endp);
2379 urb->transfer_buffer = usbvision->sbuf[buf_idx].data;
2383 usbvision->isoc_packet_size * USBVISION_URB_FRAMES;
2385 k += usbvision->isoc_packet_size) {
2388 usbvision->isoc_packet_size;
2394 err_code = usb_submit_urb(usbvision->sbuf[buf_idx].urb,
2397 dev_err(&usbvision->dev->dev,
2403 usbvision->streaming = stream_idle;
2404 PDEBUG(DBG_ISOC, "%s: streaming=1 usbvision->video_endp=$%02x",
2406 usbvision->video_endp);
2417 void usbvision_stop_isoc(struct usb_usbvision *usbvision)
2420 int sb_size = USBVISION_URB_FRAMES * usbvision->isoc_packet_size;
2422 if ((usbvision->streaming == stream_off) || (usbvision->dev == NULL))
2427 usb_kill_urb(usbvision->sbuf[buf_idx].urb);
2428 if (usbvision->sbuf[buf_idx].data) {
2429 usb_free_coherent(usbvision->dev,
2431 usbvision->sbuf[buf_idx].data,
2432 usbvision->sbuf[buf_idx].urb->transfer_dma);
2434 usb_free_urb(usbvision->sbuf[buf_idx].urb);
2435 usbvision->sbuf[buf_idx].urb = NULL;
2439 usbvision->streaming = stream_off;
2441 if (!usbvision->remove_pending) {
2443 usbvision->iface_alt = 0;
2444 err_code = usb_set_interface(usbvision->dev, usbvision->iface,
2445 usbvision->iface_alt);
2447 dev_err(&usbvision->dev->dev,
2450 usbvision->last_error = err_code;
2452 reg_value = (16-usbvision_read_reg(usbvision, USBVISION_ALTER_REG)) & 0x0F;
2453 usbvision->isoc_packet_size =
2456 usbvision->isoc_packet_size);
2458 usbvision->usb_bandwidth = reg_value >> 1;
2460 usbvision->usb_bandwidth);
2464 int usbvision_muxsel(struct usb_usbvision *usbvision, int channel)
2475 RESTRICT_TO_RANGE(channel, 0, usbvision->video_inputs);
2476 usbvision->ctl_input = channel;
2482 switch (usbvision_device_data[usbvision->dev_model].codec) {
2501 call_all(usbvision, video, s_routing, mode[channel], 0, 0);
2502 usbvision_set_audio(usbvision, audio[channel]);