linux/drivers/media/usb/usbtv/usbtv-video.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2013,2016 Lubomir Rintel
   3 * All rights reserved.
   4 *
   5 * Redistribution and use in source and binary forms, with or without
   6 * modification, are permitted provided that the following conditions
   7 * are met:
   8 * 1. Redistributions of source code must retain the above copyright
   9 *    notice, this list of conditions, and the following disclaimer,
  10 *    without modification.
  11 * 2. The name of the author may not be used to endorse or promote products
  12 *    derived from this software without specific prior written permission.
  13 *
  14 * Alternatively, this software may be distributed under the terms of the
  15 * GNU General Public License ("GPL").
  16 *
  17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29/*
  30 * Fushicai USBTV007 Audio-Video Grabber Driver
  31 *
  32 * Product web site:
  33 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html
  34 *
  35 * Following LWN articles were very useful in construction of this driver:
  36 * Video4Linux2 API series: http://lwn.net/Articles/203924/
  37 * videobuf2 API explanation: http://lwn.net/Articles/447435/
  38 * Thanks go to Jonathan Corbet for providing this quality documentation.
  39 * He is awesome.
  40 *
  41 * No physical hardware was harmed running Windows during the
  42 * reverse-engineering activity
  43 */
  44
  45#include <media/v4l2-ioctl.h>
  46#include <media/videobuf2-v4l2.h>
  47
  48#include "usbtv.h"
  49
  50static struct usbtv_norm_params norm_params[] = {
  51        {
  52                .norm = V4L2_STD_525_60,
  53                .cap_width = 720,
  54                .cap_height = 480,
  55        },
  56        {
  57                .norm = V4L2_STD_625_50,
  58                .cap_width = 720,
  59                .cap_height = 576,
  60        }
  61};
  62
  63static int usbtv_configure_for_norm(struct usbtv *usbtv, v4l2_std_id norm)
  64{
  65        int i, ret = 0;
  66        struct usbtv_norm_params *params = NULL;
  67
  68        for (i = 0; i < ARRAY_SIZE(norm_params); i++) {
  69                if (norm_params[i].norm & norm) {
  70                        params = &norm_params[i];
  71                        break;
  72                }
  73        }
  74
  75        if (params) {
  76                usbtv->width = params->cap_width;
  77                usbtv->height = params->cap_height;
  78                usbtv->n_chunks = usbtv->width * usbtv->height
  79                                                / 4 / USBTV_CHUNK;
  80                usbtv->norm = norm;
  81        } else
  82                ret = -EINVAL;
  83
  84        return ret;
  85}
  86
  87static int usbtv_select_input(struct usbtv *usbtv, int input)
  88{
  89        int ret;
  90
  91        static const u16 composite[][2] = {
  92                { USBTV_BASE + 0x0105, 0x0060 },
  93                { USBTV_BASE + 0x011f, 0x00f2 },
  94                { USBTV_BASE + 0x0127, 0x0060 },
  95                { USBTV_BASE + 0x00ae, 0x0010 },
  96                { USBTV_BASE + 0x0239, 0x0060 },
  97        };
  98
  99        static const u16 svideo[][2] = {
 100                { USBTV_BASE + 0x0105, 0x0010 },
 101                { USBTV_BASE + 0x011f, 0x00ff },
 102                { USBTV_BASE + 0x0127, 0x0060 },
 103                { USBTV_BASE + 0x00ae, 0x0030 },
 104                { USBTV_BASE + 0x0239, 0x0060 },
 105        };
 106
 107        switch (input) {
 108        case USBTV_COMPOSITE_INPUT:
 109                ret = usbtv_set_regs(usbtv, composite, ARRAY_SIZE(composite));
 110                break;
 111        case USBTV_SVIDEO_INPUT:
 112                ret = usbtv_set_regs(usbtv, svideo, ARRAY_SIZE(svideo));
 113                break;
 114        default:
 115                ret = -EINVAL;
 116        }
 117
 118        if (!ret)
 119                usbtv->input = input;
 120
 121        return ret;
 122}
 123
 124static uint16_t usbtv_norm_to_16f_reg(v4l2_std_id norm)
 125{
 126        /* NTSC M/M-JP/M-KR */
 127        if (norm & V4L2_STD_NTSC)
 128                return 0x00b8;
 129        /* PAL BG/DK/H/I */
 130        if (norm & V4L2_STD_PAL)
 131                return 0x00ee;
 132        /* SECAM B/D/G/H/K/K1/L/Lc */
 133        if (norm & V4L2_STD_SECAM)
 134                return 0x00ff;
 135        if (norm & V4L2_STD_NTSC_443)
 136                return 0x00a8;
 137        if (norm & (V4L2_STD_PAL_M | V4L2_STD_PAL_60))
 138                return 0x00bc;
 139        /* Fallback to automatic detection for other standards */
 140        return 0x0000;
 141}
 142
 143static int usbtv_select_norm(struct usbtv *usbtv, v4l2_std_id norm)
 144{
 145        int ret;
 146        /* These are the series of register values used to configure the
 147         * decoder for a specific standard.
 148         * The first 21 register writes are copied from the
 149         * Settings\DecoderDefaults registry keys present in the Windows driver
 150         * .INF file, and control various image tuning parameters (color
 151         * correction, sharpness, ...).
 152         */
 153        static const u16 pal[][2] = {
 154                /* "AVPAL" tuning sequence from .INF file */
 155                { USBTV_BASE + 0x0003, 0x0004 },
 156                { USBTV_BASE + 0x001a, 0x0068 },
 157                { USBTV_BASE + 0x0100, 0x00d3 },
 158                { USBTV_BASE + 0x010e, 0x0072 },
 159                { USBTV_BASE + 0x010f, 0x00a2 },
 160                { USBTV_BASE + 0x0112, 0x00b0 },
 161                { USBTV_BASE + 0x0115, 0x0015 },
 162                { USBTV_BASE + 0x0117, 0x0001 },
 163                { USBTV_BASE + 0x0118, 0x002c },
 164                { USBTV_BASE + 0x012d, 0x0010 },
 165                { USBTV_BASE + 0x012f, 0x0020 },
 166                { USBTV_BASE + 0x0220, 0x002e },
 167                { USBTV_BASE + 0x0225, 0x0008 },
 168                { USBTV_BASE + 0x024e, 0x0002 },
 169                { USBTV_BASE + 0x024f, 0x0002 },
 170                { USBTV_BASE + 0x0254, 0x0059 },
 171                { USBTV_BASE + 0x025a, 0x0016 },
 172                { USBTV_BASE + 0x025b, 0x0035 },
 173                { USBTV_BASE + 0x0263, 0x0017 },
 174                { USBTV_BASE + 0x0266, 0x0016 },
 175                { USBTV_BASE + 0x0267, 0x0036 },
 176                /* End image tuning */
 177                { USBTV_BASE + 0x024e, 0x0002 },
 178                { USBTV_BASE + 0x024f, 0x0002 },
 179        };
 180
 181        static const u16 ntsc[][2] = {
 182                /* "AVNTSC" tuning sequence from .INF file */
 183                { USBTV_BASE + 0x0003, 0x0004 },
 184                { USBTV_BASE + 0x001a, 0x0079 },
 185                { USBTV_BASE + 0x0100, 0x00d3 },
 186                { USBTV_BASE + 0x010e, 0x0068 },
 187                { USBTV_BASE + 0x010f, 0x009c },
 188                { USBTV_BASE + 0x0112, 0x00f0 },
 189                { USBTV_BASE + 0x0115, 0x0015 },
 190                { USBTV_BASE + 0x0117, 0x0000 },
 191                { USBTV_BASE + 0x0118, 0x00fc },
 192                { USBTV_BASE + 0x012d, 0x0004 },
 193                { USBTV_BASE + 0x012f, 0x0008 },
 194                { USBTV_BASE + 0x0220, 0x002e },
 195                { USBTV_BASE + 0x0225, 0x0008 },
 196                { USBTV_BASE + 0x024e, 0x0002 },
 197                { USBTV_BASE + 0x024f, 0x0001 },
 198                { USBTV_BASE + 0x0254, 0x005f },
 199                { USBTV_BASE + 0x025a, 0x0012 },
 200                { USBTV_BASE + 0x025b, 0x0001 },
 201                { USBTV_BASE + 0x0263, 0x001c },
 202                { USBTV_BASE + 0x0266, 0x0011 },
 203                { USBTV_BASE + 0x0267, 0x0005 },
 204                /* End image tuning */
 205                { USBTV_BASE + 0x024e, 0x0002 },
 206                { USBTV_BASE + 0x024f, 0x0002 },
 207        };
 208
 209        static const u16 secam[][2] = {
 210                /* "AVSECAM" tuning sequence from .INF file */
 211                { USBTV_BASE + 0x0003, 0x0004 },
 212                { USBTV_BASE + 0x001a, 0x0073 },
 213                { USBTV_BASE + 0x0100, 0x00dc },
 214                { USBTV_BASE + 0x010e, 0x0072 },
 215                { USBTV_BASE + 0x010f, 0x00a2 },
 216                { USBTV_BASE + 0x0112, 0x0090 },
 217                { USBTV_BASE + 0x0115, 0x0035 },
 218                { USBTV_BASE + 0x0117, 0x0001 },
 219                { USBTV_BASE + 0x0118, 0x0030 },
 220                { USBTV_BASE + 0x012d, 0x0004 },
 221                { USBTV_BASE + 0x012f, 0x0008 },
 222                { USBTV_BASE + 0x0220, 0x002d },
 223                { USBTV_BASE + 0x0225, 0x0028 },
 224                { USBTV_BASE + 0x024e, 0x0008 },
 225                { USBTV_BASE + 0x024f, 0x0002 },
 226                { USBTV_BASE + 0x0254, 0x0069 },
 227                { USBTV_BASE + 0x025a, 0x0016 },
 228                { USBTV_BASE + 0x025b, 0x0035 },
 229                { USBTV_BASE + 0x0263, 0x0021 },
 230                { USBTV_BASE + 0x0266, 0x0016 },
 231                { USBTV_BASE + 0x0267, 0x0036 },
 232                /* End image tuning */
 233                { USBTV_BASE + 0x024e, 0x0002 },
 234                { USBTV_BASE + 0x024f, 0x0002 },
 235        };
 236
 237        ret = usbtv_configure_for_norm(usbtv, norm);
 238
 239        if (!ret) {
 240                /* Masks for norms using a NTSC or PAL color encoding. */
 241                static const v4l2_std_id ntsc_mask =
 242                        V4L2_STD_NTSC | V4L2_STD_NTSC_443;
 243                static const v4l2_std_id pal_mask =
 244                        V4L2_STD_PAL | V4L2_STD_PAL_60 | V4L2_STD_PAL_M;
 245
 246                if (norm & ntsc_mask)
 247                        ret = usbtv_set_regs(usbtv, ntsc, ARRAY_SIZE(ntsc));
 248                else if (norm & pal_mask)
 249                        ret = usbtv_set_regs(usbtv, pal, ARRAY_SIZE(pal));
 250                else if (norm & V4L2_STD_SECAM)
 251                        ret = usbtv_set_regs(usbtv, secam, ARRAY_SIZE(secam));
 252                else
 253                        ret = -EINVAL;
 254        }
 255
 256        if (!ret) {
 257                /* Configure the decoder for the color standard */
 258                const u16 cfg[][2] = {
 259                        { USBTV_BASE + 0x016f, usbtv_norm_to_16f_reg(norm) }
 260                };
 261                ret = usbtv_set_regs(usbtv, cfg, ARRAY_SIZE(cfg));
 262        }
 263
 264        return ret;
 265}
 266
 267static int usbtv_setup_capture(struct usbtv *usbtv)
 268{
 269        int ret;
 270        static const u16 setup[][2] = {
 271                /* These seem to enable the device. */
 272                { USBTV_BASE + 0x0008, 0x0001 },
 273                { USBTV_BASE + 0x01d0, 0x00ff },
 274                { USBTV_BASE + 0x01d9, 0x0002 },
 275
 276                /* These seem to influence color parameters, such as
 277                 * brightness, etc. */
 278                { USBTV_BASE + 0x0239, 0x0040 },
 279                { USBTV_BASE + 0x0240, 0x0000 },
 280                { USBTV_BASE + 0x0241, 0x0000 },
 281                { USBTV_BASE + 0x0242, 0x0002 },
 282                { USBTV_BASE + 0x0243, 0x0080 },
 283                { USBTV_BASE + 0x0244, 0x0012 },
 284                { USBTV_BASE + 0x0245, 0x0090 },
 285                { USBTV_BASE + 0x0246, 0x0000 },
 286
 287                { USBTV_BASE + 0x0278, 0x002d },
 288                { USBTV_BASE + 0x0279, 0x000a },
 289                { USBTV_BASE + 0x027a, 0x0032 },
 290                { 0xf890, 0x000c },
 291                { 0xf894, 0x0086 },
 292
 293                { USBTV_BASE + 0x00ac, 0x00c0 },
 294                { USBTV_BASE + 0x00ad, 0x0000 },
 295                { USBTV_BASE + 0x00a2, 0x0012 },
 296                { USBTV_BASE + 0x00a3, 0x00e0 },
 297                { USBTV_BASE + 0x00a4, 0x0028 },
 298                { USBTV_BASE + 0x00a5, 0x0082 },
 299                { USBTV_BASE + 0x00a7, 0x0080 },
 300                { USBTV_BASE + 0x0000, 0x0014 },
 301                { USBTV_BASE + 0x0006, 0x0003 },
 302                { USBTV_BASE + 0x0090, 0x0099 },
 303                { USBTV_BASE + 0x0091, 0x0090 },
 304                { USBTV_BASE + 0x0094, 0x0068 },
 305                { USBTV_BASE + 0x0095, 0x0070 },
 306                { USBTV_BASE + 0x009c, 0x0030 },
 307                { USBTV_BASE + 0x009d, 0x00c0 },
 308                { USBTV_BASE + 0x009e, 0x00e0 },
 309                { USBTV_BASE + 0x0019, 0x0006 },
 310                { USBTV_BASE + 0x008c, 0x00ba },
 311                { USBTV_BASE + 0x0101, 0x00ff },
 312                { USBTV_BASE + 0x010c, 0x00b3 },
 313                { USBTV_BASE + 0x01b2, 0x0080 },
 314                { USBTV_BASE + 0x01b4, 0x00a0 },
 315                { USBTV_BASE + 0x014c, 0x00ff },
 316                { USBTV_BASE + 0x014d, 0x00ca },
 317                { USBTV_BASE + 0x0113, 0x0053 },
 318                { USBTV_BASE + 0x0119, 0x008a },
 319                { USBTV_BASE + 0x013c, 0x0003 },
 320                { USBTV_BASE + 0x0150, 0x009c },
 321                { USBTV_BASE + 0x0151, 0x0071 },
 322                { USBTV_BASE + 0x0152, 0x00c6 },
 323                { USBTV_BASE + 0x0153, 0x0084 },
 324                { USBTV_BASE + 0x0154, 0x00bc },
 325                { USBTV_BASE + 0x0155, 0x00a0 },
 326                { USBTV_BASE + 0x0156, 0x00a0 },
 327                { USBTV_BASE + 0x0157, 0x009c },
 328                { USBTV_BASE + 0x0158, 0x001f },
 329                { USBTV_BASE + 0x0159, 0x0006 },
 330                { USBTV_BASE + 0x015d, 0x0000 },
 331        };
 332
 333        ret = usbtv_set_regs(usbtv, setup, ARRAY_SIZE(setup));
 334        if (ret)
 335                return ret;
 336
 337        ret = usbtv_select_norm(usbtv, usbtv->norm);
 338        if (ret)
 339                return ret;
 340
 341        ret = usbtv_select_input(usbtv, usbtv->input);
 342        if (ret)
 343                return ret;
 344
 345        ret = v4l2_ctrl_handler_setup(&usbtv->ctrl);
 346        if (ret)
 347                return ret;
 348
 349        return 0;
 350}
 351
 352/* Copy data from chunk into a frame buffer, deinterlacing the data
 353 * into every second line. Unfortunately, they don't align nicely into
 354 * 720 pixel lines, as the chunk is 240 words long, which is 480 pixels.
 355 * Therefore, we break down the chunk into two halves before copying,
 356 * so that we can interleave a line if needed.
 357 *
 358 * Each "chunk" is 240 words; a word in this context equals 4 bytes.
 359 * Image format is YUYV/YUV 4:2:2, consisting of Y Cr Y Cb, defining two
 360 * pixels, the Cr and Cb shared between the two pixels, but each having
 361 * separate Y values. Thus, the 240 words equal 480 pixels. It therefore,
 362 * takes 1.5 chunks to make a 720 pixel-wide line for the frame.
 363 * The image is interlaced, so there is a "scan" of odd lines, followed
 364 * by "scan" of even numbered lines.
 365 *
 366 * Following code is writing the chunks in correct sequence, skipping
 367 * the rows based on "odd" value.
 368 * line 1: chunk[0][  0..479] chunk[0][480..959] chunk[1][  0..479]
 369 * line 3: chunk[1][480..959] chunk[2][  0..479] chunk[2][480..959]
 370 * ...etc.
 371 */
 372static void usbtv_chunk_to_vbuf(u32 *frame, __be32 *src, int chunk_no, int odd)
 373{
 374        int half;
 375
 376        for (half = 0; half < 2; half++) {
 377                int part_no = chunk_no * 2 + half;
 378                int line = part_no / 3;
 379                int part_index = (line * 2 + !odd) * 3 + (part_no % 3);
 380
 381                u32 *dst = &frame[part_index * USBTV_CHUNK/2];
 382
 383                memcpy(dst, src, USBTV_CHUNK/2 * sizeof(*src));
 384                src += USBTV_CHUNK/2;
 385        }
 386}
 387
 388/* Called for each 256-byte image chunk.
 389 * First word identifies the chunk, followed by 240 words of image
 390 * data and padding. */
 391static void usbtv_image_chunk(struct usbtv *usbtv, __be32 *chunk)
 392{
 393        int frame_id, odd, chunk_no;
 394        u32 *frame;
 395        struct usbtv_buf *buf;
 396        unsigned long flags;
 397
 398        /* Ignore corrupted lines. */
 399        if (!USBTV_MAGIC_OK(chunk))
 400                return;
 401        frame_id = USBTV_FRAME_ID(chunk);
 402        odd = USBTV_ODD(chunk);
 403        chunk_no = USBTV_CHUNK_NO(chunk);
 404        if (chunk_no >= usbtv->n_chunks)
 405                return;
 406
 407        /* Beginning of a frame. */
 408        if (chunk_no == 0) {
 409                usbtv->frame_id = frame_id;
 410                usbtv->chunks_done = 0;
 411        }
 412
 413        if (usbtv->frame_id != frame_id)
 414                return;
 415
 416        spin_lock_irqsave(&usbtv->buflock, flags);
 417        if (list_empty(&usbtv->bufs)) {
 418                /* No free buffers. Userspace likely too slow. */
 419                spin_unlock_irqrestore(&usbtv->buflock, flags);
 420                return;
 421        }
 422
 423        /* First available buffer. */
 424        buf = list_first_entry(&usbtv->bufs, struct usbtv_buf, list);
 425        frame = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
 426
 427        /* Copy the chunk data. */
 428        usbtv_chunk_to_vbuf(frame, &chunk[1], chunk_no, odd);
 429        usbtv->chunks_done++;
 430
 431        /* Last chunk in a field */
 432        if (chunk_no == usbtv->n_chunks-1) {
 433                /* Last chunk in a frame, signalling an end */
 434                if (odd && !usbtv->last_odd) {
 435                        int size = vb2_plane_size(&buf->vb.vb2_buf, 0);
 436                        enum vb2_buffer_state state = usbtv->chunks_done ==
 437                                usbtv->n_chunks ?
 438                                VB2_BUF_STATE_DONE :
 439                                VB2_BUF_STATE_ERROR;
 440
 441                        buf->vb.field = V4L2_FIELD_INTERLACED;
 442                        buf->vb.sequence = usbtv->sequence++;
 443                        buf->vb.vb2_buf.timestamp = ktime_get_ns();
 444                        vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
 445                        vb2_buffer_done(&buf->vb.vb2_buf, state);
 446                        list_del(&buf->list);
 447                }
 448                usbtv->last_odd = odd;
 449        }
 450
 451        spin_unlock_irqrestore(&usbtv->buflock, flags);
 452}
 453
 454/* Got image data. Each packet contains a number of 256-word chunks we
 455 * compose the image from. */
 456static void usbtv_iso_cb(struct urb *ip)
 457{
 458        int ret;
 459        int i;
 460        struct usbtv *usbtv = (struct usbtv *)ip->context;
 461
 462        switch (ip->status) {
 463        /* All fine. */
 464        case 0:
 465                break;
 466        /* Device disconnected or capture stopped? */
 467        case -ENODEV:
 468        case -ENOENT:
 469        case -ECONNRESET:
 470        case -ESHUTDOWN:
 471                return;
 472        /* Unknown error. Retry. */
 473        default:
 474                dev_warn(usbtv->dev, "Bad response for ISO request.\n");
 475                goto resubmit;
 476        }
 477
 478        for (i = 0; i < ip->number_of_packets; i++) {
 479                int size = ip->iso_frame_desc[i].actual_length;
 480                unsigned char *data = ip->transfer_buffer +
 481                                ip->iso_frame_desc[i].offset;
 482                int offset;
 483
 484                for (offset = 0; USBTV_CHUNK_SIZE * offset < size; offset++)
 485                        usbtv_image_chunk(usbtv,
 486                                (__be32 *)&data[USBTV_CHUNK_SIZE * offset]);
 487        }
 488
 489resubmit:
 490        ret = usb_submit_urb(ip, GFP_ATOMIC);
 491        if (ret < 0)
 492                dev_warn(usbtv->dev, "Could not resubmit ISO URB\n");
 493}
 494
 495static struct urb *usbtv_setup_iso_transfer(struct usbtv *usbtv)
 496{
 497        struct urb *ip;
 498        int size = usbtv->iso_size;
 499        int i;
 500
 501        ip = usb_alloc_urb(USBTV_ISOC_PACKETS, GFP_KERNEL);
 502        if (ip == NULL)
 503                return NULL;
 504
 505        ip->dev = usbtv->udev;
 506        ip->context = usbtv;
 507        ip->pipe = usb_rcvisocpipe(usbtv->udev, USBTV_VIDEO_ENDP);
 508        ip->interval = 1;
 509        ip->transfer_flags = URB_ISO_ASAP;
 510        ip->transfer_buffer = kcalloc(USBTV_ISOC_PACKETS, size,
 511                                                GFP_KERNEL);
 512        if (!ip->transfer_buffer) {
 513                usb_free_urb(ip);
 514                return NULL;
 515        }
 516        ip->complete = usbtv_iso_cb;
 517        ip->number_of_packets = USBTV_ISOC_PACKETS;
 518        ip->transfer_buffer_length = size * USBTV_ISOC_PACKETS;
 519        for (i = 0; i < USBTV_ISOC_PACKETS; i++) {
 520                ip->iso_frame_desc[i].offset = size * i;
 521                ip->iso_frame_desc[i].length = size;
 522        }
 523
 524        return ip;
 525}
 526
 527static void usbtv_stop(struct usbtv *usbtv)
 528{
 529        int i;
 530        unsigned long flags;
 531
 532        /* Cancel running transfers. */
 533        for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
 534                struct urb *ip = usbtv->isoc_urbs[i];
 535
 536                if (ip == NULL)
 537                        continue;
 538                usb_kill_urb(ip);
 539                kfree(ip->transfer_buffer);
 540                usb_free_urb(ip);
 541                usbtv->isoc_urbs[i] = NULL;
 542        }
 543
 544        /* Return buffers to userspace. */
 545        spin_lock_irqsave(&usbtv->buflock, flags);
 546        while (!list_empty(&usbtv->bufs)) {
 547                struct usbtv_buf *buf = list_first_entry(&usbtv->bufs,
 548                                                struct usbtv_buf, list);
 549                vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 550                list_del(&buf->list);
 551        }
 552        spin_unlock_irqrestore(&usbtv->buflock, flags);
 553}
 554
 555static int usbtv_start(struct usbtv *usbtv)
 556{
 557        int i;
 558        int ret;
 559
 560        usbtv_audio_suspend(usbtv);
 561
 562        ret = usb_set_interface(usbtv->udev, 0, 0);
 563        if (ret < 0)
 564                return ret;
 565
 566        ret = usbtv_setup_capture(usbtv);
 567        if (ret < 0)
 568                return ret;
 569
 570        ret = usb_set_interface(usbtv->udev, 0, 1);
 571        if (ret < 0)
 572                return ret;
 573
 574        usbtv_audio_resume(usbtv);
 575
 576        for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
 577                struct urb *ip;
 578
 579                ip = usbtv_setup_iso_transfer(usbtv);
 580                if (ip == NULL) {
 581                        ret = -ENOMEM;
 582                        goto start_fail;
 583                }
 584                usbtv->isoc_urbs[i] = ip;
 585
 586                ret = usb_submit_urb(ip, GFP_KERNEL);
 587                if (ret < 0)
 588                        goto start_fail;
 589        }
 590
 591        return 0;
 592
 593start_fail:
 594        usbtv_stop(usbtv);
 595        return ret;
 596}
 597
 598static int usbtv_querycap(struct file *file, void *priv,
 599                                struct v4l2_capability *cap)
 600{
 601        struct usbtv *dev = video_drvdata(file);
 602
 603        strscpy(cap->driver, "usbtv", sizeof(cap->driver));
 604        strscpy(cap->card, "usbtv", sizeof(cap->card));
 605        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 606        return 0;
 607}
 608
 609static int usbtv_enum_input(struct file *file, void *priv,
 610                                        struct v4l2_input *i)
 611{
 612        struct usbtv *dev = video_drvdata(file);
 613
 614        switch (i->index) {
 615        case USBTV_COMPOSITE_INPUT:
 616                strscpy(i->name, "Composite", sizeof(i->name));
 617                break;
 618        case USBTV_SVIDEO_INPUT:
 619                strscpy(i->name, "S-Video", sizeof(i->name));
 620                break;
 621        default:
 622                return -EINVAL;
 623        }
 624
 625        i->type = V4L2_INPUT_TYPE_CAMERA;
 626        i->std = dev->vdev.tvnorms;
 627        return 0;
 628}
 629
 630static int usbtv_enum_fmt_vid_cap(struct file *file, void  *priv,
 631                                        struct v4l2_fmtdesc *f)
 632{
 633        if (f->index > 0)
 634                return -EINVAL;
 635
 636        f->pixelformat = V4L2_PIX_FMT_YUYV;
 637        return 0;
 638}
 639
 640static int usbtv_fmt_vid_cap(struct file *file, void *priv,
 641                                        struct v4l2_format *f)
 642{
 643        struct usbtv *usbtv = video_drvdata(file);
 644
 645        f->fmt.pix.width = usbtv->width;
 646        f->fmt.pix.height = usbtv->height;
 647        f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
 648        f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 649        f->fmt.pix.bytesperline = usbtv->width * 2;
 650        f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height);
 651        f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 652
 653        return 0;
 654}
 655
 656static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 657{
 658        struct usbtv *usbtv = video_drvdata(file);
 659        *norm = usbtv->norm;
 660        return 0;
 661}
 662
 663static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm)
 664{
 665        int ret = -EINVAL;
 666        struct usbtv *usbtv = video_drvdata(file);
 667
 668        if (norm & USBTV_TV_STD)
 669                ret = usbtv_select_norm(usbtv, norm);
 670
 671        return ret;
 672}
 673
 674static int usbtv_g_input(struct file *file, void *priv, unsigned int *i)
 675{
 676        struct usbtv *usbtv = video_drvdata(file);
 677        *i = usbtv->input;
 678        return 0;
 679}
 680
 681static int usbtv_s_input(struct file *file, void *priv, unsigned int i)
 682{
 683        struct usbtv *usbtv = video_drvdata(file);
 684
 685        return usbtv_select_input(usbtv, i);
 686}
 687
 688static struct v4l2_ioctl_ops usbtv_ioctl_ops = {
 689        .vidioc_querycap = usbtv_querycap,
 690        .vidioc_enum_input = usbtv_enum_input,
 691        .vidioc_enum_fmt_vid_cap = usbtv_enum_fmt_vid_cap,
 692        .vidioc_g_fmt_vid_cap = usbtv_fmt_vid_cap,
 693        .vidioc_try_fmt_vid_cap = usbtv_fmt_vid_cap,
 694        .vidioc_s_fmt_vid_cap = usbtv_fmt_vid_cap,
 695        .vidioc_g_std = usbtv_g_std,
 696        .vidioc_s_std = usbtv_s_std,
 697        .vidioc_g_input = usbtv_g_input,
 698        .vidioc_s_input = usbtv_s_input,
 699
 700        .vidioc_reqbufs = vb2_ioctl_reqbufs,
 701        .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
 702        .vidioc_querybuf = vb2_ioctl_querybuf,
 703        .vidioc_create_bufs = vb2_ioctl_create_bufs,
 704        .vidioc_qbuf = vb2_ioctl_qbuf,
 705        .vidioc_dqbuf = vb2_ioctl_dqbuf,
 706        .vidioc_streamon = vb2_ioctl_streamon,
 707        .vidioc_streamoff = vb2_ioctl_streamoff,
 708};
 709
 710static const struct v4l2_file_operations usbtv_fops = {
 711        .owner = THIS_MODULE,
 712        .unlocked_ioctl = video_ioctl2,
 713        .mmap = vb2_fop_mmap,
 714        .open = v4l2_fh_open,
 715        .release = vb2_fop_release,
 716        .read = vb2_fop_read,
 717        .poll = vb2_fop_poll,
 718};
 719
 720static int usbtv_queue_setup(struct vb2_queue *vq,
 721        unsigned int *nbuffers,
 722        unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
 723{
 724        struct usbtv *usbtv = vb2_get_drv_priv(vq);
 725        unsigned size = USBTV_CHUNK * usbtv->n_chunks * 2 * sizeof(u32);
 726
 727        if (vq->num_buffers + *nbuffers < 2)
 728                *nbuffers = 2 - vq->num_buffers;
 729        if (*nplanes)
 730                return sizes[0] < size ? -EINVAL : 0;
 731        *nplanes = 1;
 732        sizes[0] = size;
 733
 734        return 0;
 735}
 736
 737static void usbtv_buf_queue(struct vb2_buffer *vb)
 738{
 739        struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 740        struct usbtv *usbtv = vb2_get_drv_priv(vb->vb2_queue);
 741        struct usbtv_buf *buf = container_of(vbuf, struct usbtv_buf, vb);
 742        unsigned long flags;
 743
 744        if (usbtv->udev == NULL) {
 745                vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 746                return;
 747        }
 748
 749        spin_lock_irqsave(&usbtv->buflock, flags);
 750        list_add_tail(&buf->list, &usbtv->bufs);
 751        spin_unlock_irqrestore(&usbtv->buflock, flags);
 752}
 753
 754static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count)
 755{
 756        struct usbtv *usbtv = vb2_get_drv_priv(vq);
 757
 758        if (usbtv->udev == NULL)
 759                return -ENODEV;
 760
 761        usbtv->last_odd = 1;
 762        usbtv->sequence = 0;
 763        return usbtv_start(usbtv);
 764}
 765
 766static void usbtv_stop_streaming(struct vb2_queue *vq)
 767{
 768        struct usbtv *usbtv = vb2_get_drv_priv(vq);
 769
 770        if (usbtv->udev)
 771                usbtv_stop(usbtv);
 772}
 773
 774static const struct vb2_ops usbtv_vb2_ops = {
 775        .queue_setup = usbtv_queue_setup,
 776        .buf_queue = usbtv_buf_queue,
 777        .start_streaming = usbtv_start_streaming,
 778        .stop_streaming = usbtv_stop_streaming,
 779        .wait_prepare = vb2_ops_wait_prepare,
 780        .wait_finish = vb2_ops_wait_finish,
 781};
 782
 783static int usbtv_s_ctrl(struct v4l2_ctrl *ctrl)
 784{
 785        struct usbtv *usbtv = container_of(ctrl->handler, struct usbtv,
 786                                                                ctrl);
 787        u8 *data;
 788        u16 index, size;
 789        int ret;
 790
 791        data = kmalloc(3, GFP_KERNEL);
 792        if (!data)
 793                return -ENOMEM;
 794
 795        /*
 796         * Read in the current brightness/contrast registers. We need them
 797         * both, because the values are for some reason interleaved.
 798         */
 799        if (ctrl->id == V4L2_CID_BRIGHTNESS || ctrl->id == V4L2_CID_CONTRAST) {
 800                ret = usb_control_msg(usbtv->udev,
 801                        usb_rcvctrlpipe(usbtv->udev, 0), USBTV_CONTROL_REG,
 802                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 803                        0, USBTV_BASE + 0x0244, (void *)data, 3, 0);
 804                if (ret < 0)
 805                        goto error;
 806        }
 807
 808        switch (ctrl->id) {
 809        case V4L2_CID_BRIGHTNESS:
 810                index = USBTV_BASE + 0x0244;
 811                size = 3;
 812                data[0] &= 0xf0;
 813                data[0] |= (ctrl->val >> 8) & 0xf;
 814                data[2] = ctrl->val & 0xff;
 815                break;
 816        case V4L2_CID_CONTRAST:
 817                index = USBTV_BASE + 0x0244;
 818                size = 3;
 819                data[0] &= 0x0f;
 820                data[0] |= (ctrl->val >> 4) & 0xf0;
 821                data[1] = ctrl->val & 0xff;
 822                break;
 823        case V4L2_CID_SATURATION:
 824                index = USBTV_BASE + 0x0242;
 825                data[0] = ctrl->val >> 8;
 826                data[1] = ctrl->val & 0xff;
 827                size = 2;
 828                break;
 829        case V4L2_CID_HUE:
 830                index = USBTV_BASE + 0x0240;
 831                size = 2;
 832                if (ctrl->val > 0) {
 833                        data[0] = 0x92 + (ctrl->val >> 8);
 834                        data[1] = ctrl->val & 0xff;
 835                } else {
 836                        data[0] = 0x82 + (-ctrl->val >> 8);
 837                        data[1] = -ctrl->val & 0xff;
 838                }
 839                break;
 840        case V4L2_CID_SHARPNESS:
 841                index = USBTV_BASE + 0x0239;
 842                data[0] = 0;
 843                data[1] = ctrl->val;
 844                size = 2;
 845                break;
 846        default:
 847                kfree(data);
 848                return -EINVAL;
 849        }
 850
 851        ret = usb_control_msg(usbtv->udev, usb_sndctrlpipe(usbtv->udev, 0),
 852                        USBTV_CONTROL_REG,
 853                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 854                        0, index, (void *)data, size, 0);
 855
 856error:
 857        if (ret < 0)
 858                dev_warn(usbtv->dev, "Failed to submit a control request.\n");
 859
 860        kfree(data);
 861        return ret;
 862}
 863
 864static const struct v4l2_ctrl_ops usbtv_ctrl_ops = {
 865        .s_ctrl = usbtv_s_ctrl,
 866};
 867
 868static void usbtv_release(struct v4l2_device *v4l2_dev)
 869{
 870        struct usbtv *usbtv = container_of(v4l2_dev, struct usbtv, v4l2_dev);
 871
 872        v4l2_device_unregister(&usbtv->v4l2_dev);
 873        v4l2_ctrl_handler_free(&usbtv->ctrl);
 874        vb2_queue_release(&usbtv->vb2q);
 875        kfree(usbtv);
 876}
 877
 878int usbtv_video_init(struct usbtv *usbtv)
 879{
 880        int ret;
 881
 882        (void)usbtv_configure_for_norm(usbtv, V4L2_STD_525_60);
 883
 884        spin_lock_init(&usbtv->buflock);
 885        mutex_init(&usbtv->v4l2_lock);
 886        mutex_init(&usbtv->vb2q_lock);
 887        INIT_LIST_HEAD(&usbtv->bufs);
 888
 889        /* videobuf2 structure */
 890        usbtv->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 891        usbtv->vb2q.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
 892        usbtv->vb2q.drv_priv = usbtv;
 893        usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf);
 894        usbtv->vb2q.ops = &usbtv_vb2_ops;
 895        usbtv->vb2q.mem_ops = &vb2_vmalloc_memops;
 896        usbtv->vb2q.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
 897        usbtv->vb2q.lock = &usbtv->vb2q_lock;
 898        ret = vb2_queue_init(&usbtv->vb2q);
 899        if (ret < 0) {
 900                dev_warn(usbtv->dev, "Could not initialize videobuf2 queue\n");
 901                return ret;
 902        }
 903
 904        /* controls */
 905        v4l2_ctrl_handler_init(&usbtv->ctrl, 4);
 906        v4l2_ctrl_new_std(&usbtv->ctrl, &usbtv_ctrl_ops,
 907                        V4L2_CID_CONTRAST, 0, 0x3ff, 1, 0x1d0);
 908        v4l2_ctrl_new_std(&usbtv->ctrl, &usbtv_ctrl_ops,
 909                        V4L2_CID_BRIGHTNESS, 0, 0x3ff, 1, 0x1c0);
 910        v4l2_ctrl_new_std(&usbtv->ctrl, &usbtv_ctrl_ops,
 911                        V4L2_CID_SATURATION, 0, 0x3ff, 1, 0x200);
 912        v4l2_ctrl_new_std(&usbtv->ctrl, &usbtv_ctrl_ops,
 913                        V4L2_CID_HUE, -0xdff, 0xdff, 1, 0x000);
 914        v4l2_ctrl_new_std(&usbtv->ctrl, &usbtv_ctrl_ops,
 915                        V4L2_CID_SHARPNESS, 0x0, 0xff, 1, 0x60);
 916        ret = usbtv->ctrl.error;
 917        if (ret < 0) {
 918                dev_warn(usbtv->dev, "Could not initialize controls\n");
 919                goto ctrl_fail;
 920        }
 921
 922        /* v4l2 structure */
 923        usbtv->v4l2_dev.ctrl_handler = &usbtv->ctrl;
 924        usbtv->v4l2_dev.release = usbtv_release;
 925        ret = v4l2_device_register(usbtv->dev, &usbtv->v4l2_dev);
 926        if (ret < 0) {
 927                dev_warn(usbtv->dev, "Could not register v4l2 device\n");
 928                goto v4l2_fail;
 929        }
 930
 931        /* Video structure */
 932        strscpy(usbtv->vdev.name, "usbtv", sizeof(usbtv->vdev.name));
 933        usbtv->vdev.v4l2_dev = &usbtv->v4l2_dev;
 934        usbtv->vdev.release = video_device_release_empty;
 935        usbtv->vdev.fops = &usbtv_fops;
 936        usbtv->vdev.ioctl_ops = &usbtv_ioctl_ops;
 937        usbtv->vdev.tvnorms = USBTV_TV_STD;
 938        usbtv->vdev.queue = &usbtv->vb2q;
 939        usbtv->vdev.lock = &usbtv->v4l2_lock;
 940        usbtv->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
 941                                  V4L2_CAP_STREAMING;
 942        video_set_drvdata(&usbtv->vdev, usbtv);
 943        ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);
 944        if (ret < 0) {
 945                dev_warn(usbtv->dev, "Could not register video device\n");
 946                goto vdev_fail;
 947        }
 948
 949        return 0;
 950
 951vdev_fail:
 952        v4l2_device_unregister(&usbtv->v4l2_dev);
 953v4l2_fail:
 954ctrl_fail:
 955        v4l2_ctrl_handler_free(&usbtv->ctrl);
 956        vb2_queue_release(&usbtv->vb2q);
 957
 958        return ret;
 959}
 960
 961void usbtv_video_free(struct usbtv *usbtv)
 962{
 963        mutex_lock(&usbtv->vb2q_lock);
 964        mutex_lock(&usbtv->v4l2_lock);
 965
 966        usbtv_stop(usbtv);
 967        video_unregister_device(&usbtv->vdev);
 968        v4l2_device_disconnect(&usbtv->v4l2_dev);
 969
 970        mutex_unlock(&usbtv->v4l2_lock);
 971        mutex_unlock(&usbtv->vb2q_lock);
 972
 973        v4l2_device_put(&usbtv->v4l2_dev);
 974}
 975