drivers/media/usb/usbtv/usbtv-video.c

   1 /*
   2  * Fushicai USBTV007 Video Grabber Driver
   3  *
   4  * Product web site:
   5  * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html
   6  *
   7  * Following LWN articles were very useful in construction of this driver:
   8  * Video4Linux2 API series: http://lwn.net/Articles/203924/
   9  * videobuf2 API explanation: http://lwn.net/Articles/447435/
  10  * Thanks go to Jonathan Corbet for providing this quality documentation.
  11  * He is awesome.
  12  *
  13  * Copyright (c) 2013 Lubomir Rintel
  14  * All rights reserved.
  15  * No physical hardware was harmed running Windows during the
  16  * reverse-engineering activity
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions
  20  * are met:
  21  * 1. Redistributions of source code must retain the above copyright
  22  *    notice, this list of conditions, and the following disclaimer,
  23  *    without modification.
  24  * 2. The name of the author may not be used to endorse or promote products
  25  *    derived from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL").
  29  */
  30
  31 #include <media/v4l2-ioctl.h>
  32 #include <media/videobuf2-core.h>
  33
  34 #include "usbtv.h"
  35
  36 static struct usbtv_norm_params norm_params[] = {
  37         {
  38                 .norm = V4L2_STD_525_60,
  39                 .cap_width = 720,
  40                 .cap_height = 480,
  41         },
  42         {
  43                 .norm = V4L2_STD_PAL,
  44                 .cap_width = 720,
  45                 .cap_height = 576,
  46         }
  47 };
  48
  49 static int usbtv_configure_for_norm(struct usbtv *usbtv, v4l2_std_id norm)
  50 {
  51         int i, ret = 0;
  52         struct usbtv_norm_params *params = NULL;
  53
  54         for (i = 0; i < ARRAY_SIZE(norm_params); i++) {
  55                 if (norm_params[i].norm & norm) {
  56                         params = &norm_params[i];
  57                         break;
  58                 }
  59         }
  60
  61         if (params) {
  62                 usbtv->width = params->cap_width;
  63                 usbtv->height = params->cap_height;
  64                 usbtv->n_chunks = usbtv->width * usbtv->height
  65                                                 / 4 / USBTV_CHUNK;
  66                 usbtv->norm = params->norm;
  67         } else
  68                 ret = -EINVAL;
  69
  70         return ret;
  71 }
  72
  73 static int usbtv_select_input(struct usbtv *usbtv, int input)
  74 {
  75         int ret;
  76
  77         static const u16 composite[][2] = {
  78                 { USBTV_BASE + 0x0105, 0x0060 },
  79                 { USBTV_BASE + 0x011f, 0x00f2 },
  80                 { USBTV_BASE + 0x0127, 0x0060 },
  81                 { USBTV_BASE + 0x00ae, 0x0010 },
  82                 { USBTV_BASE + 0x0284, 0x00aa },
  83                 { USBTV_BASE + 0x0239, 0x0060 },
  84         };
  85
  86         static const u16 svideo[][2] = {
  87                 { USBTV_BASE + 0x0105, 0x0010 },
  88                 { USBTV_BASE + 0x011f, 0x00ff },
  89                 { USBTV_BASE + 0x0127, 0x0060 },
  90                 { USBTV_BASE + 0x00ae, 0x0030 },
  91                 { USBTV_BASE + 0x0284, 0x0088 },
  92                 { USBTV_BASE + 0x0239, 0x0060 },
  93         };
  94
  95         switch (input) {
  96         case USBTV_COMPOSITE_INPUT:
  97                 ret = usbtv_set_regs(usbtv, composite, ARRAY_SIZE(composite));
  98                 break;
  99         case USBTV_SVIDEO_INPUT:
 100                 ret = usbtv_set_regs(usbtv, svideo, ARRAY_SIZE(svideo));
 101                 break;
 102         default:
 103                 ret = -EINVAL;
 104         }
 105
 106         if (!ret)
 107                 usbtv->input = input;
 108
 109         return ret;
 110 }
 111
 112 static int usbtv_select_norm(struct usbtv *usbtv, v4l2_std_id norm)
 113 {
 114         int ret;
 115         static const u16 pal[][2] = {
 116                 { USBTV_BASE + 0x001a, 0x0068 },
 117                 { USBTV_BASE + 0x010e, 0x0072 },
 118                 { USBTV_BASE + 0x010f, 0x00a2 },
 119                 { USBTV_BASE + 0x0112, 0x00b0 },
 120                 { USBTV_BASE + 0x0117, 0x0001 },
 121                 { USBTV_BASE + 0x0118, 0x002c },
 122                 { USBTV_BASE + 0x012d, 0x0010 },
 123                 { USBTV_BASE + 0x012f, 0x0020 },
 124                 { USBTV_BASE + 0x024f, 0x0002 },
 125                 { USBTV_BASE + 0x0254, 0x0059 },
 126                 { USBTV_BASE + 0x025a, 0x0016 },
 127                 { USBTV_BASE + 0x025b, 0x0035 },
 128                 { USBTV_BASE + 0x0263, 0x0017 },
 129                 { USBTV_BASE + 0x0266, 0x0016 },
 130                 { USBTV_BASE + 0x0267, 0x0036 }
 131         };
 132
 133         static const u16 ntsc[][2] = {
 134                 { USBTV_BASE + 0x001a, 0x0079 },
 135                 { USBTV_BASE + 0x010e, 0x0068 },
 136                 { USBTV_BASE + 0x010f, 0x009c },
 137                 { USBTV_BASE + 0x0112, 0x00f0 },
 138                 { USBTV_BASE + 0x0117, 0x0000 },
 139                 { USBTV_BASE + 0x0118, 0x00fc },
 140                 { USBTV_BASE + 0x012d, 0x0004 },
 141                 { USBTV_BASE + 0x012f, 0x0008 },
 142                 { USBTV_BASE + 0x024f, 0x0001 },
 143                 { USBTV_BASE + 0x0254, 0x005f },
 144                 { USBTV_BASE + 0x025a, 0x0012 },
 145                 { USBTV_BASE + 0x025b, 0x0001 },
 146                 { USBTV_BASE + 0x0263, 0x001c },
 147                 { USBTV_BASE + 0x0266, 0x0011 },
 148                 { USBTV_BASE + 0x0267, 0x0005 }
 149         };
 150
 151         ret = usbtv_configure_for_norm(usbtv, norm);
 152
 153         if (!ret) {
 154                 if (norm & V4L2_STD_525_60)
 155                         ret = usbtv_set_regs(usbtv, ntsc, ARRAY_SIZE(ntsc));
 156                 else if (norm & V4L2_STD_PAL)
 157                         ret = usbtv_set_regs(usbtv, pal, ARRAY_SIZE(pal));
 158         }
 159
 160         return ret;
 161 }
 162
 163 static int usbtv_setup_capture(struct usbtv *usbtv)
 164 {
 165         int ret;
 166         static const u16 setup[][2] = {
 167                 /* These seem to enable the device. */
 168                 { USBTV_BASE + 0x0008, 0x0001 },
 169                 { USBTV_BASE + 0x01d0, 0x00ff },
 170                 { USBTV_BASE + 0x01d9, 0x0002 },
 171
 172                 /* These seem to influence color parameters, such as
 173                  * brightness, etc. */
 174                 { USBTV_BASE + 0x0239, 0x0040 },
 175                 { USBTV_BASE + 0x0240, 0x0000 },
 176                 { USBTV_BASE + 0x0241, 0x0000 },
 177                 { USBTV_BASE + 0x0242, 0x0002 },
 178                 { USBTV_BASE + 0x0243, 0x0080 },
 179                 { USBTV_BASE + 0x0244, 0x0012 },
 180                 { USBTV_BASE + 0x0245, 0x0090 },
 181                 { USBTV_BASE + 0x0246, 0x0000 },
 182
 183                 { USBTV_BASE + 0x0278, 0x002d },
 184                 { USBTV_BASE + 0x0279, 0x000a },
 185                 { USBTV_BASE + 0x027a, 0x0032 },
 186                 { 0xf890, 0x000c },
 187                 { 0xf894, 0x0086 },
 188
 189                 { USBTV_BASE + 0x00ac, 0x00c0 },
 190                 { USBTV_BASE + 0x00ad, 0x0000 },
 191                 { USBTV_BASE + 0x00a2, 0x0012 },
 192                 { USBTV_BASE + 0x00a3, 0x00e0 },
 193                 { USBTV_BASE + 0x00a4, 0x0028 },
 194                 { USBTV_BASE + 0x00a5, 0x0082 },
 195                 { USBTV_BASE + 0x00a7, 0x0080 },
 196                 { USBTV_BASE + 0x0000, 0x0014 },
 197                 { USBTV_BASE + 0x0006, 0x0003 },
 198                 { USBTV_BASE + 0x0090, 0x0099 },
 199                 { USBTV_BASE + 0x0091, 0x0090 },
 200                 { USBTV_BASE + 0x0094, 0x0068 },
 201                 { USBTV_BASE + 0x0095, 0x0070 },
 202                 { USBTV_BASE + 0x009c, 0x0030 },
 203                 { USBTV_BASE + 0x009d, 0x00c0 },
 204                 { USBTV_BASE + 0x009e, 0x00e0 },
 205                 { USBTV_BASE + 0x0019, 0x0006 },
 206                 { USBTV_BASE + 0x008c, 0x00ba },
 207                 { USBTV_BASE + 0x0101, 0x00ff },
 208                 { USBTV_BASE + 0x010c, 0x00b3 },
 209                 { USBTV_BASE + 0x01b2, 0x0080 },
 210                 { USBTV_BASE + 0x01b4, 0x00a0 },
 211                 { USBTV_BASE + 0x014c, 0x00ff },
 212                 { USBTV_BASE + 0x014d, 0x00ca },
 213                 { USBTV_BASE + 0x0113, 0x0053 },
 214                 { USBTV_BASE + 0x0119, 0x008a },
 215                 { USBTV_BASE + 0x013c, 0x0003 },
 216                 { USBTV_BASE + 0x0150, 0x009c },
 217                 { USBTV_BASE + 0x0151, 0x0071 },
 218                 { USBTV_BASE + 0x0152, 0x00c6 },
 219                 { USBTV_BASE + 0x0153, 0x0084 },
 220                 { USBTV_BASE + 0x0154, 0x00bc },
 221                 { USBTV_BASE + 0x0155, 0x00a0 },
 222                 { USBTV_BASE + 0x0156, 0x00a0 },
 223                 { USBTV_BASE + 0x0157, 0x009c },
 224                 { USBTV_BASE + 0x0158, 0x001f },
 225                 { USBTV_BASE + 0x0159, 0x0006 },
 226                 { USBTV_BASE + 0x015d, 0x0000 },
 227
 228                 { USBTV_BASE + 0x0284, 0x0088 },
 229                 { USBTV_BASE + 0x0003, 0x0004 },
 230                 { USBTV_BASE + 0x0100, 0x00d3 },
 231                 { USBTV_BASE + 0x0115, 0x0015 },
 232                 { USBTV_BASE + 0x0220, 0x002e },
 233                 { USBTV_BASE + 0x0225, 0x0008 },
 234                 { USBTV_BASE + 0x024e, 0x0002 },
 235                 { USBTV_BASE + 0x024e, 0x0002 },
 236                 { USBTV_BASE + 0x024f, 0x0002 },
 237         };
 238
 239         ret = usbtv_set_regs(usbtv, setup, ARRAY_SIZE(setup));
 240         if (ret)
 241                 return ret;
 242
 243         ret = usbtv_select_norm(usbtv, usbtv->norm);
 244         if (ret)
 245                 return ret;
 246
 247         ret = usbtv_select_input(usbtv, usbtv->input);
 248         if (ret)
 249                 return ret;
 250
 251         return 0;
 252 }
 253
 254 /* Copy data from chunk into a frame buffer, deinterlacing the data
 255  * into every second line. Unfortunately, they don't align nicely into
 256  * 720 pixel lines, as the chunk is 240 words long, which is 480 pixels.
 257  * Therefore, we break down the chunk into two halves before copyting,
 258  * so that we can interleave a line if needed. */
 259 static void usbtv_chunk_to_vbuf(u32 *frame, u32 *src, int chunk_no, int odd)
 260 {
 261         int half;
 262
 263         for (half = 0; half < 2; half++) {
 264                 int part_no = chunk_no * 2 + half;
 265                 int line = part_no / 3;
 266                 int part_index = (line * 2 + !odd) * 3 + (part_no % 3);
 267
 268                 u32 *dst = &frame[part_index * USBTV_CHUNK/2];
 269                 memcpy(dst, src, USBTV_CHUNK/2 * sizeof(*src));
 270                 src += USBTV_CHUNK/2;
 271         }
 272 }
 273
 274 /* Called for each 256-byte image chunk.
 275  * First word identifies the chunk, followed by 240 words of image
 276  * data and padding. */
 277 static void usbtv_image_chunk(struct usbtv *usbtv, u32 *chunk)
 278 {
 279         int frame_id, odd, chunk_no;
 280         u32 *frame;
 281         struct usbtv_buf *buf;
 282         unsigned long flags;
 283
 284         /* Ignore corrupted lines. */
 285         if (!USBTV_MAGIC_OK(chunk))
 286                 return;
 287         frame_id = USBTV_FRAME_ID(chunk);
 288         odd = USBTV_ODD(chunk);
 289         chunk_no = USBTV_CHUNK_NO(chunk);
 290         if (chunk_no >= usbtv->n_chunks)
 291                 return;
 292
 293         /* Beginning of a frame. */
 294         if (chunk_no == 0) {
 295                 usbtv->frame_id = frame_id;
 296                 usbtv->chunks_done = 0;
 297         }
 298
 299         if (usbtv->frame_id != frame_id)
 300                 return;
 301
 302         spin_lock_irqsave(&usbtv->buflock, flags);
 303         if (list_empty(&usbtv->bufs)) {
 304                 /* No free buffers. Userspace likely too slow. */
 305                 spin_unlock_irqrestore(&usbtv->buflock, flags);
 306                 return;
 307         }
 308
 309         /* First available buffer. */
 310         buf = list_first_entry(&usbtv->bufs, struct usbtv_buf, list);
 311         frame = vb2_plane_vaddr(&buf->vb, 0);
 312
 313         /* Copy the chunk data. */
 314         usbtv_chunk_to_vbuf(frame, &chunk[1], chunk_no, odd);
 315         usbtv->chunks_done++;
 316
 317         /* Last chunk in a frame, signalling an end */
 318         if (odd && chunk_no == usbtv->n_chunks-1) {
 319                 int size = vb2_plane_size(&buf->vb, 0);
 320                 enum vb2_buffer_state state = usbtv->chunks_done ==
 321                                                 usbtv->n_chunks ?
 322                                                 VB2_BUF_STATE_DONE :
 323                                                 VB2_BUF_STATE_ERROR;
 324
 325                 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
 326                 buf->vb.v4l2_buf.sequence = usbtv->sequence++;
 327                 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 328                 vb2_set_plane_payload(&buf->vb, 0, size);
 329                 vb2_buffer_done(&buf->vb, state);
 330                 list_del(&buf->list);
 331         }
 332
 333         spin_unlock_irqrestore(&usbtv->buflock, flags);
 334 }
 335
 336 /* Got image data. Each packet contains a number of 256-word chunks we
 337  * compose the image from. */
 338 static void usbtv_iso_cb(struct urb *ip)
 339 {
 340         int ret;
 341         int i;
 342         struct usbtv *usbtv = (struct usbtv *)ip->context;
 343
 344         switch (ip->status) {
 345         /* All fine. */
 346         case 0:
 347                 break;
 348         /* Device disconnected or capture stopped? */
 349         case -ENODEV:
 350         case -ENOENT:
 351         case -ECONNRESET:
 352         case -ESHUTDOWN:
 353                 return;
 354         /* Unknown error. Retry. */
 355         default:
 356                 dev_warn(usbtv->dev, "Bad response for ISO request.\n");
 357                 goto resubmit;
 358         }
 359
 360         for (i = 0; i < ip->number_of_packets; i++) {
 361                 int size = ip->iso_frame_desc[i].actual_length;
 362                 unsigned char *data = ip->transfer_buffer +
 363                                 ip->iso_frame_desc[i].offset;
 364                 int offset;
 365
 366                 for (offset = 0; USBTV_CHUNK_SIZE * offset < size; offset++)
 367                         usbtv_image_chunk(usbtv,
 368                                 (u32 *)&data[USBTV_CHUNK_SIZE * offset]);
 369         }
 370
 371 resubmit:
 372         ret = usb_submit_urb(ip, GFP_ATOMIC);
 373         if (ret < 0)
 374                 dev_warn(usbtv->dev, "Could not resubmit ISO URB\n");
 375 }
 376
 377 static struct urb *usbtv_setup_iso_transfer(struct usbtv *usbtv)
 378 {
 379         struct urb *ip;
 380         int size = usbtv->iso_size;
 381         int i;
 382
 383         ip = usb_alloc_urb(USBTV_ISOC_PACKETS, GFP_KERNEL);
 384         if (ip == NULL)
 385                 return NULL;
 386
 387         ip->dev = usbtv->udev;
 388         ip->context = usbtv;
 389         ip->pipe = usb_rcvisocpipe(usbtv->udev, USBTV_VIDEO_ENDP);
 390         ip->interval = 1;
 391         ip->transfer_flags = URB_ISO_ASAP;
 392         ip->transfer_buffer = kzalloc(size * USBTV_ISOC_PACKETS,
 393                                                 GFP_KERNEL);
 394         ip->complete = usbtv_iso_cb;
 395         ip->number_of_packets = USBTV_ISOC_PACKETS;
 396         ip->transfer_buffer_length = size * USBTV_ISOC_PACKETS;
 397         for (i = 0; i < USBTV_ISOC_PACKETS; i++) {
 398                 ip->iso_frame_desc[i].offset = size * i;
 399                 ip->iso_frame_desc[i].length = size;
 400         }
 401
 402         return ip;
 403 }
 404
 405 static void usbtv_stop(struct usbtv *usbtv)
 406 {
 407         int i;
 408         unsigned long flags;
 409
 410         /* Cancel running transfers. */
 411         for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
 412                 struct urb *ip = usbtv->isoc_urbs[i];
 413                 if (ip == NULL)
 414                         continue;
 415                 usb_kill_urb(ip);
 416                 kfree(ip->transfer_buffer);
 417                 usb_free_urb(ip);
 418                 usbtv->isoc_urbs[i] = NULL;
 419         }
 420
 421         /* Return buffers to userspace. */
 422         spin_lock_irqsave(&usbtv->buflock, flags);
 423         while (!list_empty(&usbtv->bufs)) {
 424                 struct usbtv_buf *buf = list_first_entry(&usbtv->bufs,
 425                                                 struct usbtv_buf, list);
 426                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
 427                 list_del(&buf->list);
 428         }
 429         spin_unlock_irqrestore(&usbtv->buflock, flags);
 430 }
 431
 432 static int usbtv_start(struct usbtv *usbtv)
 433 {
 434         int i;
 435         int ret;
 436
 437         ret = usb_set_interface(usbtv->udev, 0, 0);
 438         if (ret < 0)
 439                 return ret;
 440
 441         ret = usbtv_setup_capture(usbtv);
 442         if (ret < 0)
 443                 return ret;
 444
 445         ret = usb_set_interface(usbtv->udev, 0, 1);
 446         if (ret < 0)
 447                 return ret;
 448
 449         for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
 450                 struct urb *ip;
 451
 452                 ip = usbtv_setup_iso_transfer(usbtv);
 453                 if (ip == NULL) {
 454                         ret = -ENOMEM;
 455                         goto start_fail;
 456                 }
 457                 usbtv->isoc_urbs[i] = ip;
 458
 459                 ret = usb_submit_urb(ip, GFP_KERNEL);
 460                 if (ret < 0)
 461                         goto start_fail;
 462         }
 463
 464         return 0;
 465
 466 start_fail:
 467         usbtv_stop(usbtv);
 468         return ret;
 469 }
 470
 471 static int usbtv_querycap(struct file *file, void *priv,
 472                                 struct v4l2_capability *cap)
 473 {
 474         struct usbtv *dev = video_drvdata(file);
 475
 476         strlcpy(cap->driver, "usbtv", sizeof(cap->driver));
 477         strlcpy(cap->card, "usbtv", sizeof(cap->card));
 478         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 479         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE;
 480         cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
 481         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 482         return 0;
 483 }
 484
 485 static int usbtv_enum_input(struct file *file, void *priv,
 486                                         struct v4l2_input *i)
 487 {
 488         struct usbtv *dev = video_drvdata(file);
 489
 490         switch (i->index) {
 491         case USBTV_COMPOSITE_INPUT:
 492                 strlcpy(i->name, "Composite", sizeof(i->name));
 493                 break;
 494         case USBTV_SVIDEO_INPUT:
 495                 strlcpy(i->name, "S-Video", sizeof(i->name));
 496                 break;
 497         default:
 498                 return -EINVAL;
 499         }
 500
 501         i->type = V4L2_INPUT_TYPE_CAMERA;
 502         i->std = dev->vdev.tvnorms;
 503         return 0;
 504 }
 505
 506 static int usbtv_enum_fmt_vid_cap(struct file *file, void  *priv,
 507                                         struct v4l2_fmtdesc *f)
 508 {
 509         if (f->index > 0)
 510                 return -EINVAL;
 511
 512         strlcpy(f->description, "16 bpp YUY2, 4:2:2, packed",
 513                                         sizeof(f->description));
 514         f->pixelformat = V4L2_PIX_FMT_YUYV;
 515         return 0;
 516 }
 517
 518 static int usbtv_fmt_vid_cap(struct file *file, void *priv,
 519                                         struct v4l2_format *f)
 520 {
 521         struct usbtv *usbtv = video_drvdata(file);
 522
 523         f->fmt.pix.width = usbtv->width;
 524         f->fmt.pix.height = usbtv->height;
 525         f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
 526         f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 527         f->fmt.pix.bytesperline = usbtv->width * 2;
 528         f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height);
 529         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 530
 531         return 0;
 532 }
 533
 534 static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 535 {
 536         struct usbtv *usbtv = video_drvdata(file);
 537         *norm = usbtv->norm;
 538         return 0;
 539 }
 540
 541 static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm)
 542 {
 543         int ret = -EINVAL;
 544         struct usbtv *usbtv = video_drvdata(file);
 545
 546         if ((norm & V4L2_STD_525_60) || (norm & V4L2_STD_PAL))
 547                 ret = usbtv_select_norm(usbtv, norm);
 548
 549         return ret;
 550 }
 551
 552 static int usbtv_g_input(struct file *file, void *priv, unsigned int *i)
 553 {
 554         struct usbtv *usbtv = video_drvdata(file);
 555         *i = usbtv->input;
 556         return 0;
 557 }
 558
 559 static int usbtv_s_input(struct file *file, void *priv, unsigned int i)
 560 {
 561         struct usbtv *usbtv = video_drvdata(file);
 562         return usbtv_select_input(usbtv, i);
 563 }
 564
 565 static struct v4l2_ioctl_ops usbtv_ioctl_ops = {
 566         .vidioc_querycap = usbtv_querycap,
 567         .vidioc_enum_input = usbtv_enum_input,
 568         .vidioc_enum_fmt_vid_cap = usbtv_enum_fmt_vid_cap,
 569         .vidioc_g_fmt_vid_cap = usbtv_fmt_vid_cap,
 570         .vidioc_try_fmt_vid_cap = usbtv_fmt_vid_cap,
 571         .vidioc_s_fmt_vid_cap = usbtv_fmt_vid_cap,
 572         .vidioc_g_std = usbtv_g_std,
 573         .vidioc_s_std = usbtv_s_std,
 574         .vidioc_g_input = usbtv_g_input,
 575         .vidioc_s_input = usbtv_s_input,
 576
 577         .vidioc_reqbufs = vb2_ioctl_reqbufs,
 578         .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
 579         .vidioc_querybuf = vb2_ioctl_querybuf,
 580         .vidioc_create_bufs = vb2_ioctl_create_bufs,
 581         .vidioc_qbuf = vb2_ioctl_qbuf,
 582         .vidioc_dqbuf = vb2_ioctl_dqbuf,
 583         .vidioc_streamon = vb2_ioctl_streamon,
 584         .vidioc_streamoff = vb2_ioctl_streamoff,
 585 };
 586
 587 static struct v4l2_file_operations usbtv_fops = {
 588         .owner = THIS_MODULE,
 589         .unlocked_ioctl = video_ioctl2,
 590         .mmap = vb2_fop_mmap,
 591         .open = v4l2_fh_open,
 592         .release = vb2_fop_release,
 593         .read = vb2_fop_read,
 594         .poll = vb2_fop_poll,
 595 };
 596
 597 static int usbtv_queue_setup(struct vb2_queue *vq,
 598         const struct v4l2_format *v4l_fmt, unsigned int *nbuffers,
 599         unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[])
 600 {
 601         struct usbtv *usbtv = vb2_get_drv_priv(vq);
 602
 603         if (*nbuffers < 2)
 604                 *nbuffers = 2;
 605         *nplanes = 1;
 606         sizes[0] = USBTV_CHUNK * usbtv->n_chunks * 2 * sizeof(u32);
 607
 608         return 0;
 609 }
 610
 611 static void usbtv_buf_queue(struct vb2_buffer *vb)
 612 {
 613         struct usbtv *usbtv = vb2_get_drv_priv(vb->vb2_queue);
 614         struct usbtv_buf *buf = container_of(vb, struct usbtv_buf, vb);
 615         unsigned long flags;
 616
 617         if (usbtv->udev == NULL) {
 618                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 619                 return;
 620         }
 621
 622         spin_lock_irqsave(&usbtv->buflock, flags);
 623         list_add_tail(&buf->list, &usbtv->bufs);
 624         spin_unlock_irqrestore(&usbtv->buflock, flags);
 625 }
 626
 627 static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count)
 628 {
 629         struct usbtv *usbtv = vb2_get_drv_priv(vq);
 630
 631         if (usbtv->udev == NULL)
 632                 return -ENODEV;
 633
 634         return usbtv_start(usbtv);
 635 }
 636
 637 static int usbtv_stop_streaming(struct vb2_queue *vq)
 638 {
 639         struct usbtv *usbtv = vb2_get_drv_priv(vq);
 640
 641         if (usbtv->udev == NULL)
 642                 return -ENODEV;
 643
 644         usbtv_stop(usbtv);
 645         return 0;
 646 }
 647
 648 static struct vb2_ops usbtv_vb2_ops = {
 649         .queue_setup = usbtv_queue_setup,
 650         .buf_queue = usbtv_buf_queue,
 651         .start_streaming = usbtv_start_streaming,
 652         .stop_streaming = usbtv_stop_streaming,
 653 };
 654
 655 static void usbtv_release(struct v4l2_device *v4l2_dev)
 656 {
 657         struct usbtv *usbtv = container_of(v4l2_dev, struct usbtv, v4l2_dev);
 658
 659         v4l2_device_unregister(&usbtv->v4l2_dev);
 660         vb2_queue_release(&usbtv->vb2q);
 661         kfree(usbtv);
 662 }
 663
 664 int usbtv_video_init(struct usbtv *usbtv)
 665 {
 666         int ret;
 667
 668         (void)usbtv_configure_for_norm(usbtv, V4L2_STD_525_60);
 669
 670         spin_lock_init(&usbtv->buflock);
 671         mutex_init(&usbtv->v4l2_lock);
 672         mutex_init(&usbtv->vb2q_lock);
 673         INIT_LIST_HEAD(&usbtv->bufs);
 674
 675         /* videobuf2 structure */
 676         usbtv->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 677         usbtv->vb2q.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
 678         usbtv->vb2q.drv_priv = usbtv;
 679         usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf);
 680         usbtv->vb2q.ops = &usbtv_vb2_ops;
 681         usbtv->vb2q.mem_ops = &vb2_vmalloc_memops;
 682         usbtv->vb2q.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
 683         usbtv->vb2q.lock = &usbtv->vb2q_lock;
 684         ret = vb2_queue_init(&usbtv->vb2q);
 685         if (ret < 0) {
 686                 dev_warn(usbtv->dev, "Could not initialize videobuf2 queue\n");
 687                 return ret;
 688         }
 689
 690         /* v4l2 structure */
 691         usbtv->v4l2_dev.release = usbtv_release;
 692         ret = v4l2_device_register(usbtv->dev, &usbtv->v4l2_dev);
 693         if (ret < 0) {
 694                 dev_warn(usbtv->dev, "Could not register v4l2 device\n");
 695                 goto v4l2_fail;
 696         }
 697
 698         /* Video structure */
 699         strlcpy(usbtv->vdev.name, "usbtv", sizeof(usbtv->vdev.name));
 700         usbtv->vdev.v4l2_dev = &usbtv->v4l2_dev;
 701         usbtv->vdev.release = video_device_release_empty;
 702         usbtv->vdev.fops = &usbtv_fops;
 703         usbtv->vdev.ioctl_ops = &usbtv_ioctl_ops;
 704         usbtv->vdev.tvnorms = USBTV_TV_STD;
 705         usbtv->vdev.queue = &usbtv->vb2q;
 706         usbtv->vdev.lock = &usbtv->v4l2_lock;
 707         set_bit(V4L2_FL_USE_FH_PRIO, &usbtv->vdev.flags);
 708         video_set_drvdata(&usbtv->vdev, usbtv);
 709         ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);
 710         if (ret < 0) {
 711                 dev_warn(usbtv->dev, "Could not register video device\n");
 712                 goto vdev_fail;
 713         }
 714
 715         return 0;
 716
 717 vdev_fail:
 718         v4l2_device_unregister(&usbtv->v4l2_dev);
 719 v4l2_fail:
 720         vb2_queue_release(&usbtv->vb2q);
 721
 722         return ret;
 723 }
 724
 725 void usbtv_video_free(struct usbtv *usbtv)
 726 {
 727         mutex_lock(&usbtv->vb2q_lock);
 728         mutex_lock(&usbtv->v4l2_lock);
 729
 730         usbtv_stop(usbtv);
 731         video_unregister_device(&usbtv->vdev);
 732         v4l2_device_disconnect(&usbtv->v4l2_dev);
 733
 734         mutex_unlock(&usbtv->v4l2_lock);
 735         mutex_unlock(&usbtv->vb2q_lock);
 736
 737         v4l2_device_put(&usbtv->v4l2_dev);
 738 }