← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/media/video/tm6000/tm6000-video.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/tm6000/tm6000-video.c
 
1
/*
 
2
 *   tm6000-video.c - driver for TM5600/TM6000/TM6010 USB video capture devices
 
3
 *
 
4
 *  Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
 
5
 *
 
6
 *  Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
 
7
 *      - Fixed module load/unload
 
8
 *
 
9
 *  This program is free software; you can redistribute it and/or modify
 
10
 *  it under the terms of the GNU General Public License as published by
 
11
 *  the Free Software Foundation version 2
 
12
 *
 
13
 *  This program is distributed in the hope that it will be useful,
 
14
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 *  GNU General Public License for more details.
 
17
 *
 
18
 *  You should have received a copy of the GNU General Public License
 
19
 *  along with this program; if not, write to the Free Software
 
20
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
21
 */
 
22
 
 
23
#include <linux/module.h>
 
24
#include <linux/delay.h>
 
25
#include <linux/errno.h>
 
26
#include <linux/fs.h>
 
27
#include <linux/kernel.h>
 
28
#include <linux/slab.h>
 
29
#include <linux/mm.h>
 
30
#include <linux/ioport.h>
 
31
#include <linux/init.h>
 
32
#include <linux/sched.h>
 
33
#include <linux/random.h>
 
34
#include <linux/usb.h>
 
35
#include <linux/videodev2.h>
 
36
#include <media/v4l2-ioctl.h>
 
37
#include <media/tuner.h>
 
38
#include <linux/interrupt.h>
 
39
#include <linux/kthread.h>
 
40
#include <linux/highmem.h>
 
41
#include <linux/freezer.h>
 
42
 
 
43
#include "tm6000-regs.h"
 
44
#include "tm6000.h"
 
45
 
 
46
#define BUFFER_TIMEOUT     msecs_to_jiffies(2000)  /* 2 seconds */
 
47
 
 
48
/* Limits minimum and default number of buffers */
 
49
#define TM6000_MIN_BUF 4
 
50
#define TM6000_DEF_BUF 8
 
51
 
 
52
#define TM6000_MAX_ISO_PACKETS  46      /* Max number of ISO packets */
 
53
 
 
54
/* Declare static vars that will be used as parameters */
 
55
static unsigned int vid_limit = 16;     /* Video memory limit, in Mb */
 
56
static int video_nr = -1;               /* /dev/videoN, -1 for autodetect */
 
57
static int radio_nr = -1;               /* /dev/radioN, -1 for autodetect */
 
58
 
 
59
/* Debug level */
 
60
int tm6000_debug;
 
61
EXPORT_SYMBOL_GPL(tm6000_debug);
 
62
 
 
63
static const struct v4l2_queryctrl no_ctrl = {
 
64
        .name  = "42",
 
65
        .flags = V4L2_CTRL_FLAG_DISABLED,
 
66
};
 
67
 
 
68
/* supported controls */
 
69
static struct v4l2_queryctrl tm6000_qctrl[] = {
 
70
        {
 
71
                .id            = V4L2_CID_BRIGHTNESS,
 
72
                .type          = V4L2_CTRL_TYPE_INTEGER,
 
73
                .name          = "Brightness",
 
74
                .minimum       = 0,
 
75
                .maximum       = 255,
 
76
                .step          = 1,
 
77
                .default_value = 54,
 
78
                .flags         = 0,
 
79
        }, {
 
80
                .id            = V4L2_CID_CONTRAST,
 
81
                .type          = V4L2_CTRL_TYPE_INTEGER,
 
82
                .name          = "Contrast",
 
83
                .minimum       = 0,
 
84
                .maximum       = 255,
 
85
                .step          = 0x1,
 
86
                .default_value = 119,
 
87
                .flags         = 0,
 
88
        }, {
 
89
                .id            = V4L2_CID_SATURATION,
 
90
                .type          = V4L2_CTRL_TYPE_INTEGER,
 
91
                .name          = "Saturation",
 
92
                .minimum       = 0,
 
93
                .maximum       = 255,
 
94
                .step          = 0x1,
 
95
                .default_value = 112,
 
96
                .flags         = 0,
 
97
        }, {
 
98
                .id            = V4L2_CID_HUE,
 
99
                .type          = V4L2_CTRL_TYPE_INTEGER,
 
100
                .name          = "Hue",
 
101
                .minimum       = -128,
 
102
                .maximum       = 127,
 
103
                .step          = 0x1,
 
104
                .default_value = 0,
 
105
                .flags         = 0,
 
106
        },
 
107
                /* --- audio --- */
 
108
        {
 
109
                .id            = V4L2_CID_AUDIO_MUTE,
 
110
                .name          = "Mute",
 
111
                .minimum       = 0,
 
112
                .maximum       = 1,
 
113
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
 
114
        }, {
 
115
                .id            = V4L2_CID_AUDIO_VOLUME,
 
116
                .name          = "Volume",
 
117
                .minimum       = -15,
 
118
                .maximum       = 15,
 
119
                .step          = 1,
 
120
                .default_value = 0,
 
121
                .type          = V4L2_CTRL_TYPE_INTEGER,
 
122
        }
 
123
};
 
124
 
 
125
static const unsigned int CTRLS = ARRAY_SIZE(tm6000_qctrl);
 
126
static int qctl_regs[ARRAY_SIZE(tm6000_qctrl)];
 
127
 
 
128
static struct tm6000_fmt format[] = {
 
129
        {
 
130
                .name     = "4:2:2, packed, YVY2",
 
131
                .fourcc   = V4L2_PIX_FMT_YUYV,
 
132
                .depth    = 16,
 
133
        }, {
 
134
                .name     = "4:2:2, packed, UYVY",
 
135
                .fourcc   = V4L2_PIX_FMT_UYVY,
 
136
                .depth    = 16,
 
137
        }, {
 
138
                .name     = "A/V + VBI mux packet",
 
139
                .fourcc   = V4L2_PIX_FMT_TM6000,
 
140
                .depth    = 16,
 
141
        }
 
142
};
 
143
 
 
144
static const struct v4l2_queryctrl *ctrl_by_id(unsigned int id)
 
145
{
 
146
        unsigned int i;
 
147
 
 
148
        for (i = 0; i < CTRLS; i++)
 
149
                if (tm6000_qctrl[i].id == id)
 
150
                        return tm6000_qctrl+i;
 
151
        return NULL;
 
152
}
 
153
 
 
154
/* ------------------------------------------------------------------
 
155
 *      DMA and thread functions
 
156
 * ------------------------------------------------------------------
 
157
 */
 
158
 
 
159
#define norm_maxw(a) 720
 
160
#define norm_maxh(a) 576
 
161
 
 
162
#define norm_minw(a) norm_maxw(a)
 
163
#define norm_minh(a) norm_maxh(a)
 
164
 
 
165
/*
 
166
 * video-buf generic routine to get the next available buffer
 
167
 */
 
168
static inline void get_next_buf(struct tm6000_dmaqueue *dma_q,
 
169
                               struct tm6000_buffer   **buf)
 
170
{
 
171
        struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
 
172
        char *outp;
 
173
 
 
174
        if (list_empty(&dma_q->active)) {
 
175
                dprintk(dev, V4L2_DEBUG_QUEUE, "No active queue to serve\n");
 
176
                *buf = NULL;
 
177
                return;
 
178
        }
 
179
 
 
180
        *buf = list_entry(dma_q->active.next,
 
181
                        struct tm6000_buffer, vb.queue);
 
182
 
 
183
        /* Cleans up buffer - Useful for testing for frame/URB loss */
 
184
        outp = videobuf_to_vmalloc(&(*buf)->vb);
 
185
 
 
186
        return;
 
187
}
 
188
 
 
189
/*
 
190
 * Announces that a buffer were filled and request the next
 
191
 */
 
192
static inline void buffer_filled(struct tm6000_core *dev,
 
193
                                 struct tm6000_dmaqueue *dma_q,
 
194
                                 struct tm6000_buffer *buf)
 
195
{
 
196
        /* Advice that buffer was filled */
 
197
        dprintk(dev, V4L2_DEBUG_ISOC, "[%p/%d] wakeup\n", buf, buf->vb.i);
 
198
        buf->vb.state = VIDEOBUF_DONE;
 
199
        buf->vb.field_count++;
 
200
        do_gettimeofday(&buf->vb.ts);
 
201
 
 
202
        list_del(&buf->vb.queue);
 
203
        wake_up(&buf->vb.done);
 
204
}
 
205
 
 
206
/*
 
207
 * Identify the tm5600/6000 buffer header type and properly handles
 
208
 */
 
209
static int copy_streams(u8 *data, unsigned long len,
 
210
                        struct urb *urb)
 
211
{
 
212
        struct tm6000_dmaqueue  *dma_q = urb->context;
 
213
        struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
 
214
        u8 *ptr = data, *endp = data+len, c;
 
215
        unsigned long header = 0;
 
216
        int rc = 0;
 
217
        unsigned int cmd, cpysize, pktsize, size, field, block, line, pos = 0;
 
218
        struct tm6000_buffer *vbuf = NULL;
 
219
        char *voutp = NULL;
 
220
        unsigned int linewidth;
 
221
 
 
222
        if (!dev->radio) {
 
223
                /* get video buffer */
 
224
                get_next_buf(dma_q, &vbuf);
 
225
 
 
226
                if (!vbuf)
 
227
                        return rc;
 
228
                voutp = videobuf_to_vmalloc(&vbuf->vb);
 
229
 
 
230
                if (!voutp)
 
231
                        return 0;
 
232
        }
 
233
 
 
234
        for (ptr = data; ptr < endp;) {
 
235
                if (!dev->isoc_ctl.cmd) {
 
236
                        /* Header */
 
237
                        if (dev->isoc_ctl.tmp_buf_len > 0) {
 
238
                                /* from last urb or packet */
 
239
                                header = dev->isoc_ctl.tmp_buf;
 
240
                                if (4 - dev->isoc_ctl.tmp_buf_len > 0) {
 
241
                                        memcpy((u8 *)&header +
 
242
                                                dev->isoc_ctl.tmp_buf_len,
 
243
                                                ptr,
 
244
                                                4 - dev->isoc_ctl.tmp_buf_len);
 
245
                                        ptr += 4 - dev->isoc_ctl.tmp_buf_len;
 
246
                                }
 
247
                                dev->isoc_ctl.tmp_buf_len = 0;
 
248
                        } else {
 
249
                                if (ptr + 3 >= endp) {
 
250
                                        /* have incomplete header */
 
251
                                        dev->isoc_ctl.tmp_buf_len = endp - ptr;
 
252
                                        memcpy(&dev->isoc_ctl.tmp_buf, ptr,
 
253
                                                dev->isoc_ctl.tmp_buf_len);
 
254
                                        return rc;
 
255
                                }
 
256
                                /* Seek for sync */
 
257
                                for (; ptr < endp - 3; ptr++) {
 
258
                                        if (*(ptr + 3) == 0x47)
 
259
                                                break;
 
260
                                }
 
261
                                /* Get message header */
 
262
                                header = *(unsigned long *)ptr;
 
263
                                ptr += 4;
 
264
                        }
 
265
 
 
266
                        /* split the header fields */
 
267
                        c = (header >> 24) & 0xff;
 
268
                        size = ((header & 0x7e) << 1);
 
269
                        if (size > 0)
 
270
                                size -= 4;
 
271
                        block = (header >> 7) & 0xf;
 
272
                        field = (header >> 11) & 0x1;
 
273
                        line  = (header >> 12) & 0x1ff;
 
274
                        cmd   = (header >> 21) & 0x7;
 
275
                        /* Validates haeder fields */
 
276
                        if (size > TM6000_URB_MSG_LEN)
 
277
                                size = TM6000_URB_MSG_LEN;
 
278
                        pktsize = TM6000_URB_MSG_LEN;
 
279
                        /*
 
280
                         * calculate position in buffer and change the buffer
 
281
                         */
 
282
                        switch (cmd) {
 
283
                        case TM6000_URB_MSG_VIDEO:
 
284
                                if (!dev->radio) {
 
285
                                        if ((dev->isoc_ctl.vfield != field) &&
 
286
                                                (field == 1)) {
 
287
                                                /*
 
288
                                                 * Announces that a new buffer
 
289
                                                 * were filled
 
290
                                                 */
 
291
                                                buffer_filled(dev, dma_q, vbuf);
 
292
                                                dprintk(dev, V4L2_DEBUG_ISOC,
 
293
                                                        "new buffer filled\n");
 
294
                                                get_next_buf(dma_q, &vbuf);
 
295
                                                if (!vbuf)
 
296
                                                        return rc;
 
297
                                                voutp = videobuf_to_vmalloc(&vbuf->vb);
 
298
                                                if (!voutp)
 
299
                                                        return rc;
 
300
                                                memset(voutp, 0, vbuf->vb.size);
 
301
                                        }
 
302
                                        linewidth = vbuf->vb.width << 1;
 
303
                                        pos = ((line << 1) - field - 1) *
 
304
                                        linewidth + block * TM6000_URB_MSG_LEN;
 
305
                                        /* Don't allow to write out of the buffer */
 
306
                                        if (pos + size > vbuf->vb.size)
 
307
                                                cmd = TM6000_URB_MSG_ERR;
 
308
                                        dev->isoc_ctl.vfield = field;
 
309
                                }
 
310
                                break;
 
311
                        case TM6000_URB_MSG_VBI:
 
312
                                break;
 
313
                        case TM6000_URB_MSG_AUDIO:
 
314
                        case TM6000_URB_MSG_PTS:
 
315
                                size = pktsize; /* Size is always 180 bytes */
 
316
                                break;
 
317
                        }
 
318
                } else {
 
319
                        /* Continue the last copy */
 
320
                        cmd = dev->isoc_ctl.cmd;
 
321
                        size = dev->isoc_ctl.size;
 
322
                        pos = dev->isoc_ctl.pos;
 
323
                        pktsize = dev->isoc_ctl.pktsize;
 
324
                        field = dev->isoc_ctl.field;
 
325
                }
 
326
                cpysize = (endp - ptr > size) ? size : endp - ptr;
 
327
                if (cpysize) {
 
328
                        /* copy data in different buffers */
 
329
                        switch (cmd) {
 
330
                        case TM6000_URB_MSG_VIDEO:
 
331
                                /* Fills video buffer */
 
332
                                if (vbuf)
 
333
                                        memcpy(&voutp[pos], ptr, cpysize);
 
334
                                break;
 
335
                        case TM6000_URB_MSG_AUDIO: {
 
336
                                int i;
 
337
                                for (i = 0; i < cpysize; i += 2)
 
338
                                        swab16s((u16 *)(ptr + i));
 
339
 
 
340
                                tm6000_call_fillbuf(dev, TM6000_AUDIO, ptr, cpysize);
 
341
                                break;
 
342
                        }
 
343
                        case TM6000_URB_MSG_VBI:
 
344
                                /* Need some code to copy vbi buffer */
 
345
                                break;
 
346
                        case TM6000_URB_MSG_PTS: {
 
347
                                /* Need some code to copy pts */
 
348
                                u32 pts;
 
349
                                pts = *(u32 *)ptr;
 
350
                                dprintk(dev, V4L2_DEBUG_ISOC, "field %d, PTS %x",
 
351
                                        field, pts);
 
352
                                break;
 
353
                        }
 
354
                        }
 
355
                }
 
356
                if (ptr + pktsize > endp) {
 
357
                        /*
 
358
                         * End of URB packet, but cmd processing is not
 
359
                         * complete. Preserve the state for a next packet
 
360
                         */
 
361
                        dev->isoc_ctl.pos = pos + cpysize;
 
362
                        dev->isoc_ctl.size = size - cpysize;
 
363
                        dev->isoc_ctl.cmd = cmd;
 
364
                        dev->isoc_ctl.field = field;
 
365
                        dev->isoc_ctl.pktsize = pktsize - (endp - ptr);
 
366
                        ptr += endp - ptr;
 
367
                } else {
 
368
                        dev->isoc_ctl.cmd = 0;
 
369
                        ptr += pktsize;
 
370
                }
 
371
        }
 
372
        return 0;
 
373
}
 
374
 
 
375
/*
 
376
 * Identify the tm5600/6000 buffer header type and properly handles
 
377
 */
 
378
static int copy_multiplexed(u8 *ptr, unsigned long len,
 
379
                        struct urb *urb)
 
380
{
 
381
        struct tm6000_dmaqueue  *dma_q = urb->context;
 
382
        struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
 
383
        unsigned int pos = dev->isoc_ctl.pos, cpysize;
 
384
        int rc = 1;
 
385
        struct tm6000_buffer *buf;
 
386
        char *outp = NULL;
 
387
 
 
388
        get_next_buf(dma_q, &buf);
 
389
        if (buf)
 
390
                outp = videobuf_to_vmalloc(&buf->vb);
 
391
 
 
392
        if (!outp)
 
393
                return 0;
 
394
 
 
395
        while (len > 0) {
 
396
                cpysize = min(len, buf->vb.size-pos);
 
397
                memcpy(&outp[pos], ptr, cpysize);
 
398
                pos += cpysize;
 
399
                ptr += cpysize;
 
400
                len -= cpysize;
 
401
                if (pos >= buf->vb.size) {
 
402
                        pos = 0;
 
403
                        /* Announces that a new buffer were filled */
 
404
                        buffer_filled(dev, dma_q, buf);
 
405
                        dprintk(dev, V4L2_DEBUG_ISOC, "new buffer filled\n");
 
406
                        get_next_buf(dma_q, &buf);
 
407
                        if (!buf)
 
408
                                break;
 
409
                        outp = videobuf_to_vmalloc(&(buf->vb));
 
410
                        if (!outp)
 
411
                                return rc;
 
412
                        pos = 0;
 
413
                }
 
414
        }
 
415
 
 
416
        dev->isoc_ctl.pos = pos;
 
417
        return rc;
 
418
}
 
419
 
 
420
static inline void print_err_status(struct tm6000_core *dev,
 
421
                                     int packet, int status)
 
422
{
 
423
        char *errmsg = "Unknown";
 
424
 
 
425
        switch (status) {
 
426
        case -ENOENT:
 
427
                errmsg = "unlinked synchronuously";
 
428
                break;
 
429
        case -ECONNRESET:
 
430
                errmsg = "unlinked asynchronuously";
 
431
                break;
 
432
        case -ENOSR:
 
433
                errmsg = "Buffer error (overrun)";
 
434
                break;
 
435
        case -EPIPE:
 
436
                errmsg = "Stalled (device not responding)";
 
437
                break;
 
438
        case -EOVERFLOW:
 
439
                errmsg = "Babble (bad cable?)";
 
440
                break;
 
441
        case -EPROTO:
 
442
                errmsg = "Bit-stuff error (bad cable?)";
 
443
                break;
 
444
        case -EILSEQ:
 
445
                errmsg = "CRC/Timeout (could be anything)";
 
446
                break;
 
447
        case -ETIME:
 
448
                errmsg = "Device does not respond";
 
449
                break;
 
450
        }
 
451
        if (packet < 0) {
 
452
                dprintk(dev, V4L2_DEBUG_QUEUE, "URB status %d [%s].\n",
 
453
                        status, errmsg);
 
454
        } else {
 
455
                dprintk(dev, V4L2_DEBUG_QUEUE, "URB packet %d, status %d [%s].\n",
 
456
                        packet, status, errmsg);
 
457
        }
 
458
}
 
459
 
 
460
 
 
461
/*
 
462
 * Controls the isoc copy of each urb packet
 
463
 */
 
464
static inline int tm6000_isoc_copy(struct urb *urb)
 
465
{
 
466
        struct tm6000_dmaqueue  *dma_q = urb->context;
 
467
        struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
 
468
        int i, len = 0, rc = 1, status;
 
469
        char *p;
 
470
 
 
471
        if (urb->status < 0) {
 
472
                print_err_status(dev, -1, urb->status);
 
473
                return 0;
 
474
        }
 
475
 
 
476
        for (i = 0; i < urb->number_of_packets; i++) {
 
477
                status = urb->iso_frame_desc[i].status;
 
478
 
 
479
                if (status < 0) {
 
480
                        print_err_status(dev, i, status);
 
481
                        continue;
 
482
                }
 
483
 
 
484
                len = urb->iso_frame_desc[i].actual_length;
 
485
 
 
486
                if (len > 0) {
 
487
                        p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
 
488
                        if (!urb->iso_frame_desc[i].status) {
 
489
                                if ((dev->fourcc) == V4L2_PIX_FMT_TM6000) {
 
490
                                        rc = copy_multiplexed(p, len, urb);
 
491
                                        if (rc <= 0)
 
492
                                                return rc;
 
493
                                } else {
 
494
                                        copy_streams(p, len, urb);
 
495
                                }
 
496
                        }
 
497
                }
 
498
        }
 
499
        return rc;
 
500
}
 
501
 
 
502
/* ------------------------------------------------------------------
 
503
 *      URB control
 
504
 * ------------------------------------------------------------------
 
505
 */
 
506
 
 
507
/*
 
508
 * IRQ callback, called by URB callback
 
509
 */
 
510
static void tm6000_irq_callback(struct urb *urb)
 
511
{
 
512
        struct tm6000_dmaqueue  *dma_q = urb->context;
 
513
        struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
 
514
        int i;
 
515
 
 
516
        switch (urb->status) {
 
517
        case 0:
 
518
        case -ETIMEDOUT:
 
519
                break;
 
520
 
 
521
        case -ECONNRESET:
 
522
        case -ENOENT:
 
523
        case -ESHUTDOWN:
 
524
                return;
 
525
 
 
526
        default:
 
527
                tm6000_err("urb completion error %d.\n", urb->status);
 
528
                break;
 
529
        }
 
530
 
 
531
        spin_lock(&dev->slock);
 
532
        tm6000_isoc_copy(urb);
 
533
        spin_unlock(&dev->slock);
 
534
 
 
535
        /* Reset urb buffers */
 
536
        for (i = 0; i < urb->number_of_packets; i++) {
 
537
                urb->iso_frame_desc[i].status = 0;
 
538
                urb->iso_frame_desc[i].actual_length = 0;
 
539
        }
 
540
 
 
541
        urb->status = usb_submit_urb(urb, GFP_ATOMIC);
 
542
        if (urb->status)
 
543
                tm6000_err("urb resubmit failed (error=%i)\n",
 
544
                        urb->status);
 
545
}
 
546
 
 
547
/*
 
548
 * Stop and Deallocate URBs
 
549
 */
 
550
static void tm6000_uninit_isoc(struct tm6000_core *dev)
 
551
{
 
552
        struct urb *urb;
 
553
        int i;
 
554
 
 
555
        dev->isoc_ctl.buf = NULL;
 
556
        for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 
557
                urb = dev->isoc_ctl.urb[i];
 
558
                if (urb) {
 
559
                        usb_kill_urb(urb);
 
560
                        usb_unlink_urb(urb);
 
561
                        if (dev->isoc_ctl.transfer_buffer[i]) {
 
562
                                usb_free_coherent(dev->udev,
 
563
                                                urb->transfer_buffer_length,
 
564
                                                dev->isoc_ctl.transfer_buffer[i],
 
565
                                                urb->transfer_dma);
 
566
                        }
 
567
                        usb_free_urb(urb);
 
568
                        dev->isoc_ctl.urb[i] = NULL;
 
569
                }
 
570
                dev->isoc_ctl.transfer_buffer[i] = NULL;
 
571
        }
 
572
 
 
573
        kfree(dev->isoc_ctl.urb);
 
574
        kfree(dev->isoc_ctl.transfer_buffer);
 
575
 
 
576
        dev->isoc_ctl.urb = NULL;
 
577
        dev->isoc_ctl.transfer_buffer = NULL;
 
578
        dev->isoc_ctl.num_bufs = 0;
 
579
}
 
580
 
 
581
/*
 
582
 * Allocate URBs and start IRQ
 
583
 */
 
584
static int tm6000_prepare_isoc(struct tm6000_core *dev)
 
585
{
 
586
        struct tm6000_dmaqueue *dma_q = &dev->vidq;
 
587
        int i, j, sb_size, pipe, size, max_packets, num_bufs = 8;
 
588
        struct urb *urb;
 
589
 
 
590
        /* De-allocates all pending stuff */
 
591
        tm6000_uninit_isoc(dev);
 
592
        /* Stop interrupt USB pipe */
 
593
        tm6000_ir_int_stop(dev);
 
594
 
 
595
        usb_set_interface(dev->udev,
 
596
                          dev->isoc_in.bInterfaceNumber,
 
597
                          dev->isoc_in.bAlternateSetting);
 
598
 
 
599
        /* Start interrupt USB pipe */
 
600
        tm6000_ir_int_start(dev);
 
601
 
 
602
        pipe = usb_rcvisocpipe(dev->udev,
 
603
                               dev->isoc_in.endp->desc.bEndpointAddress &
 
604
                               USB_ENDPOINT_NUMBER_MASK);
 
605
 
 
606
        size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
 
607
 
 
608
        if (size > dev->isoc_in.maxsize)
 
609
                size = dev->isoc_in.maxsize;
 
610
 
 
611
        dev->isoc_ctl.max_pkt_size = size;
 
612
 
 
613
        max_packets = TM6000_MAX_ISO_PACKETS;
 
614
        sb_size = max_packets * size;
 
615
 
 
616
        dev->isoc_ctl.num_bufs = num_bufs;
 
617
 
 
618
        dev->isoc_ctl.urb = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
 
619
        if (!dev->isoc_ctl.urb) {
 
620
                tm6000_err("cannot alloc memory for usb buffers\n");
 
621
                return -ENOMEM;
 
622
        }
 
623
 
 
624
        dev->isoc_ctl.transfer_buffer = kmalloc(sizeof(void *)*num_bufs,
 
625
                                   GFP_KERNEL);
 
626
        if (!dev->isoc_ctl.transfer_buffer) {
 
627
                tm6000_err("cannot allocate memory for usbtransfer\n");
 
628
                kfree(dev->isoc_ctl.urb);
 
629
                return -ENOMEM;
 
630
        }
 
631
 
 
632
        dprintk(dev, V4L2_DEBUG_QUEUE, "Allocating %d x %d packets"
 
633
                    " (%d bytes) of %d bytes each to handle %u size\n",
 
634
                    max_packets, num_bufs, sb_size,
 
635
                    dev->isoc_in.maxsize, size);
 
636
 
 
637
        /* allocate urbs and transfer buffers */
 
638
        for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 
639
                urb = usb_alloc_urb(max_packets, GFP_KERNEL);
 
640
                if (!urb) {
 
641
                        tm6000_err("cannot alloc isoc_ctl.urb %i\n", i);
 
642
                        tm6000_uninit_isoc(dev);
 
643
                        usb_free_urb(urb);
 
644
                        return -ENOMEM;
 
645
                }
 
646
                dev->isoc_ctl.urb[i] = urb;
 
647
 
 
648
                dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
 
649
                        sb_size, GFP_KERNEL, &urb->transfer_dma);
 
650
                if (!dev->isoc_ctl.transfer_buffer[i]) {
 
651
                        tm6000_err("unable to allocate %i bytes for transfer"
 
652
                                        " buffer %i%s\n",
 
653
                                        sb_size, i,
 
654
                                        in_interrupt() ? " while in int" : "");
 
655
                        tm6000_uninit_isoc(dev);
 
656
                        return -ENOMEM;
 
657
                }
 
658
                memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
 
659
 
 
660
                usb_fill_bulk_urb(urb, dev->udev, pipe,
 
661
                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
 
662
                                  tm6000_irq_callback, dma_q);
 
663
                urb->interval = dev->isoc_in.endp->desc.bInterval;
 
664
                urb->number_of_packets = max_packets;
 
665
                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 
666
 
 
667
                for (j = 0; j < max_packets; j++) {
 
668
                        urb->iso_frame_desc[j].offset = size * j;
 
669
                        urb->iso_frame_desc[j].length = size;
 
670
                }
 
671
        }
 
672
 
 
673
        return 0;
 
674
}
 
675
 
 
676
static int tm6000_start_thread(struct tm6000_core *dev)
 
677
{
 
678
        struct tm6000_dmaqueue *dma_q = &dev->vidq;
 
679
        int i;
 
680
 
 
681
        dma_q->frame = 0;
 
682
        dma_q->ini_jiffies = jiffies;
 
683
 
 
684
        init_waitqueue_head(&dma_q->wq);
 
685
 
 
686
        /* submit urbs and enables IRQ */
 
687
        for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
 
688
                int rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
 
689
                if (rc) {
 
690
                        tm6000_err("submit of urb %i failed (error=%i)\n", i,
 
691
                                   rc);
 
692
                        tm6000_uninit_isoc(dev);
 
693
                        return rc;
 
694
                }
 
695
        }
 
696
 
 
697
        return 0;
 
698
}
 
699
 
 
700
/* ------------------------------------------------------------------
 
701
 *      Videobuf operations
 
702
 * ------------------------------------------------------------------
 
703
 */
 
704
 
 
705
static int
 
706
buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 
707
{
 
708
        struct tm6000_fh *fh = vq->priv_data;
 
709
 
 
710
        *size = fh->fmt->depth * fh->width * fh->height >> 3;
 
711
        if (0 == *count)
 
712
                *count = TM6000_DEF_BUF;
 
713
 
 
714
        if (*count < TM6000_MIN_BUF)
 
715
                *count = TM6000_MIN_BUF;
 
716
 
 
717
        while (*size * *count > vid_limit * 1024 * 1024)
 
718
                (*count)--;
 
719
 
 
720
        return 0;
 
721
}
 
722
 
 
723
static void free_buffer(struct videobuf_queue *vq, struct tm6000_buffer *buf)
 
724
{
 
725
        struct tm6000_fh *fh = vq->priv_data;
 
726
        struct tm6000_core   *dev = fh->dev;
 
727
        unsigned long flags;
 
728
 
 
729
        if (in_interrupt())
 
730
                BUG();
 
731
 
 
732
        /* We used to wait for the buffer to finish here, but this didn't work
 
733
           because, as we were keeping the state as VIDEOBUF_QUEUED,
 
734
           videobuf_queue_cancel marked it as finished for us.
 
735
           (Also, it could wedge forever if the hardware was misconfigured.)
 
736
 
 
737
           This should be safe; by the time we get here, the buffer isn't
 
738
           queued anymore. If we ever start marking the buffers as
 
739
           VIDEOBUF_ACTIVE, it won't be, though.
 
740
        */
 
741
        spin_lock_irqsave(&dev->slock, flags);
 
742
        if (dev->isoc_ctl.buf == buf)
 
743
                dev->isoc_ctl.buf = NULL;
 
744
        spin_unlock_irqrestore(&dev->slock, flags);
 
745
 
 
746
        videobuf_vmalloc_free(&buf->vb);
 
747
        buf->vb.state = VIDEOBUF_NEEDS_INIT;
 
748
}
 
749
 
 
750
static int
 
751
buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 
752
                                                enum v4l2_field field)
 
753
{
 
754
        struct tm6000_fh     *fh  = vq->priv_data;
 
755
        struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
 
756
        struct tm6000_core   *dev = fh->dev;
 
757
        int rc = 0;
 
758
 
 
759
        BUG_ON(NULL == fh->fmt);
 
760
 
 
761
 
 
762
        /* FIXME: It assumes depth=2 */
 
763
        /* The only currently supported format is 16 bits/pixel */
 
764
        buf->vb.size = fh->fmt->depth*fh->width*fh->height >> 3;
 
765
        if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 
766
                return -EINVAL;
 
767
 
 
768
        if (buf->fmt       != fh->fmt    ||
 
769
            buf->vb.width  != fh->width  ||
 
770
            buf->vb.height != fh->height ||
 
771
            buf->vb.field  != field) {
 
772
                buf->fmt       = fh->fmt;
 
773
                buf->vb.width  = fh->width;
 
774
                buf->vb.height = fh->height;
 
775
                buf->vb.field  = field;
 
776
                buf->vb.state = VIDEOBUF_NEEDS_INIT;
 
777
        }
 
778
 
 
779
        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 
780
                rc = videobuf_iolock(vq, &buf->vb, NULL);
 
781
                if (rc != 0)
 
782
                        goto fail;
 
783
        }
 
784
 
 
785
        if (!dev->isoc_ctl.num_bufs) {
 
786
                rc = tm6000_prepare_isoc(dev);
 
787
                if (rc < 0)
 
788
                        goto fail;
 
789
 
 
790
                rc = tm6000_start_thread(dev);
 
791
                if (rc < 0)
 
792
                        goto fail;
 
793
 
 
794
        }
 
795
 
 
796
        buf->vb.state = VIDEOBUF_PREPARED;
 
797
        return 0;
 
798
 
 
799
fail:
 
800
        free_buffer(vq, buf);
 
801
        return rc;
 
802
}
 
803
 
 
804
static void
 
805
buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 
806
{
 
807
        struct tm6000_buffer    *buf     = container_of(vb, struct tm6000_buffer, vb);
 
808
        struct tm6000_fh        *fh      = vq->priv_data;
 
809
        struct tm6000_core      *dev     = fh->dev;
 
810
        struct tm6000_dmaqueue  *vidq    = &dev->vidq;
 
811
 
 
812
        buf->vb.state = VIDEOBUF_QUEUED;
 
813
        list_add_tail(&buf->vb.queue, &vidq->active);
 
814
}
 
815
 
 
816
static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 
817
{
 
818
        struct tm6000_buffer   *buf  = container_of(vb, struct tm6000_buffer, vb);
 
819
 
 
820
        free_buffer(vq, buf);
 
821
}
 
822
 
 
823
static struct videobuf_queue_ops tm6000_video_qops = {
 
824
        .buf_setup      = buffer_setup,
 
825
        .buf_prepare    = buffer_prepare,
 
826
        .buf_queue      = buffer_queue,
 
827
        .buf_release    = buffer_release,
 
828
};
 
829
 
 
830
/* ------------------------------------------------------------------
 
831
 *      IOCTL handling
 
832
 * ------------------------------------------------------------------
 
833
 */
 
834
 
 
835
static bool is_res_read(struct tm6000_core *dev, struct tm6000_fh *fh)
 
836
{
 
837
        /* Is the current fh handling it? if so, that's OK */
 
838
        if (dev->resources == fh && dev->is_res_read)
 
839
                return true;
 
840
 
 
841
        return false;
 
842
}
 
843
 
 
844
static bool is_res_streaming(struct tm6000_core *dev, struct tm6000_fh *fh)
 
845
{
 
846
        /* Is the current fh handling it? if so, that's OK */
 
847
        if (dev->resources == fh)
 
848
                return true;
 
849
 
 
850
        return false;
 
851
}
 
852
 
 
853
static bool res_get(struct tm6000_core *dev, struct tm6000_fh *fh,
 
854
                   bool is_res_read)
 
855
{
 
856
        /* Is the current fh handling it? if so, that's OK */
 
857
        if (dev->resources == fh && dev->is_res_read == is_res_read)
 
858
                return true;
 
859
 
 
860
        /* is it free? */
 
861
        if (dev->resources)
 
862
                return false;
 
863
 
 
864
        /* grab it */
 
865
        dev->resources = fh;
 
866
        dev->is_res_read = is_res_read;
 
867
        dprintk(dev, V4L2_DEBUG_RES_LOCK, "res: get\n");
 
868
        return true;
 
869
}
 
870
 
 
871
static void res_free(struct tm6000_core *dev, struct tm6000_fh *fh)
 
872
{
 
873
        /* Is the current fh handling it? if so, that's OK */
 
874
        if (dev->resources != fh)
 
875
                return;
 
876
 
 
877
        dev->resources = NULL;
 
878
        dprintk(dev, V4L2_DEBUG_RES_LOCK, "res: put\n");
 
879
}
 
880
 
 
881
/* ------------------------------------------------------------------
 
882
 *      IOCTL vidioc handling
 
883
 * ------------------------------------------------------------------
 
884
 */
 
885
static int vidioc_querycap(struct file *file, void  *priv,
 
886
                                        struct v4l2_capability *cap)
 
887
{
 
888
        struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
 
889
 
 
890
        strlcpy(cap->driver, "tm6000", sizeof(cap->driver));
 
891
        strlcpy(cap->card, "Trident TVMaster TM5600/6000/6010", sizeof(cap->card));
 
892
        cap->version = TM6000_VERSION;
 
893
        cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
 
894
                                V4L2_CAP_STREAMING     |
 
895
                                V4L2_CAP_AUDIO         |
 
896
                                V4L2_CAP_READWRITE;
 
897
 
 
898
        if (dev->tuner_type != TUNER_ABSENT)
 
899
                cap->capabilities |= V4L2_CAP_TUNER;
 
900
 
 
901
        return 0;
 
902
}
 
903
 
 
904
static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 
905
                                        struct v4l2_fmtdesc *f)
 
906
{
 
907
        if (unlikely(f->index >= ARRAY_SIZE(format)))
 
908
                return -EINVAL;
 
909
 
 
910
        strlcpy(f->description, format[f->index].name, sizeof(f->description));
 
911
        f->pixelformat = format[f->index].fourcc;
 
912
        return 0;
 
913
}
 
914
 
 
915
static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 
916
                                        struct v4l2_format *f)
 
917
{
 
918
        struct tm6000_fh  *fh = priv;
 
919
 
 
920
        f->fmt.pix.width        = fh->width;
 
921
        f->fmt.pix.height       = fh->height;
 
922
        f->fmt.pix.field        = fh->vb_vidq.field;
 
923
        f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 
924
        f->fmt.pix.bytesperline =
 
925
                (f->fmt.pix.width * fh->fmt->depth) >> 3;
 
926
        f->fmt.pix.sizeimage =
 
927
                f->fmt.pix.height * f->fmt.pix.bytesperline;
 
928
 
 
929
        return 0;
 
930
}
 
931
 
 
932
static struct tm6000_fmt *format_by_fourcc(unsigned int fourcc)
 
933
{
 
934
        unsigned int i;
 
935
 
 
936
        for (i = 0; i < ARRAY_SIZE(format); i++)
 
937
                if (format[i].fourcc == fourcc)
 
938
                        return format+i;
 
939
        return NULL;
 
940
}
 
941
 
 
942
static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 
943
                        struct v4l2_format *f)
 
944
{
 
945
        struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
 
946
        struct tm6000_fmt *fmt;
 
947
        enum v4l2_field field;
 
948
 
 
949
        fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 
950
        if (NULL == fmt) {
 
951
                dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Fourcc format (0x%08x)"
 
952
                                " invalid.\n", f->fmt.pix.pixelformat);
 
953
                return -EINVAL;
 
954
        }
 
955
 
 
956
        field = f->fmt.pix.field;
 
957
 
 
958
        if (field == V4L2_FIELD_ANY)
 
959
                field = V4L2_FIELD_SEQ_TB;
 
960
        else if (V4L2_FIELD_INTERLACED != field) {
 
961
                dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Field type invalid.\n");
 
962
                return -EINVAL;
 
963
        }
 
964
 
 
965
        tm6000_get_std_res(dev);
 
966
 
 
967
        f->fmt.pix.width  = dev->width;
 
968
        f->fmt.pix.height = dev->height;
 
969
 
 
970
        f->fmt.pix.width &= ~0x01;
 
971
 
 
972
        f->fmt.pix.field = field;
 
973
 
 
974
        f->fmt.pix.bytesperline =
 
975
                (f->fmt.pix.width * fmt->depth) >> 3;
 
976
        f->fmt.pix.sizeimage =
 
977
                f->fmt.pix.height * f->fmt.pix.bytesperline;
 
978
 
 
979
        return 0;
 
980
}
 
981
 
 
982
/*FIXME: This seems to be generic enough to be at videodev2 */
 
983
static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 
984
                                        struct v4l2_format *f)
 
985
{
 
986
        struct tm6000_fh  *fh = priv;
 
987
        struct tm6000_core *dev = fh->dev;
 
988
        int ret = vidioc_try_fmt_vid_cap(file, fh, f);
 
989
        if (ret < 0)
 
990
                return ret;
 
991
 
 
992
        fh->fmt           = format_by_fourcc(f->fmt.pix.pixelformat);
 
993
        fh->width         = f->fmt.pix.width;
 
994
        fh->height        = f->fmt.pix.height;
 
995
        fh->vb_vidq.field = f->fmt.pix.field;
 
996
        fh->type          = f->type;
 
997
 
 
998
        dev->fourcc       = f->fmt.pix.pixelformat;
 
999
 
 
1000
        tm6000_set_fourcc_format(dev);
 
1001
 
 
1002
        return 0;
 
1003
}
 
1004
 
 
1005
static int vidioc_reqbufs(struct file *file, void *priv,
 
1006
                           struct v4l2_requestbuffers *p)
 
1007
{
 
1008
        struct tm6000_fh  *fh = priv;
 
1009
 
 
1010
        return videobuf_reqbufs(&fh->vb_vidq, p);
 
1011
}
 
1012
 
 
1013
static int vidioc_querybuf(struct file *file, void *priv,
 
1014
                            struct v4l2_buffer *p)
 
1015
{
 
1016
        struct tm6000_fh  *fh = priv;
 
1017
 
 
1018
        return videobuf_querybuf(&fh->vb_vidq, p);
 
1019
}
 
1020
 
 
1021
static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 
1022
{
 
1023
        struct tm6000_fh  *fh = priv;
 
1024
 
 
1025
        return videobuf_qbuf(&fh->vb_vidq, p);
 
1026
}
 
1027
 
 
1028
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 
1029
{
 
1030
        struct tm6000_fh  *fh = priv;
 
1031
 
 
1032
        return videobuf_dqbuf(&fh->vb_vidq, p,
 
1033
                                file->f_flags & O_NONBLOCK);
 
1034
}
 
1035
 
 
1036
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 
1037
{
 
1038
        struct tm6000_fh *fh = priv;
 
1039
        struct tm6000_core *dev = fh->dev;
 
1040
 
 
1041
        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 
1042
                return -EINVAL;
 
1043
        if (i != fh->type)
 
1044
                return -EINVAL;
 
1045
 
 
1046
        if (!res_get(dev, fh, false))
 
1047
                return -EBUSY;
 
1048
        return videobuf_streamon(&fh->vb_vidq);
 
1049
}
 
1050
 
 
1051
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 
1052
{
 
1053
        struct tm6000_fh *fh = priv;
 
1054
        struct tm6000_core *dev = fh->dev;
 
1055
 
 
1056
        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 
1057
                return -EINVAL;
 
1058
 
 
1059
        if (i != fh->type)
 
1060
                return -EINVAL;
 
1061
 
 
1062
        videobuf_streamoff(&fh->vb_vidq);
 
1063
        res_free(dev, fh);
 
1064
 
 
1065
        return 0;
 
1066
}
 
1067
 
 
1068
static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
 
1069
{
 
1070
        int rc = 0;
 
1071
        struct tm6000_fh *fh = priv;
 
1072
        struct tm6000_core *dev = fh->dev;
 
1073
 
 
1074
        dev->norm = *norm;
 
1075
        rc = tm6000_init_analog_mode(dev);
 
1076
 
 
1077
        fh->width  = dev->width;
 
1078
        fh->height = dev->height;
 
1079
 
 
1080
        if (rc < 0)
 
1081
                return rc;
 
1082
 
 
1083
        v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
 
1084
 
 
1085
        return 0;
 
1086
}
 
1087
 
 
1088
static const char *iname[] = {
 
1089
        [TM6000_INPUT_TV] = "Television",
 
1090
        [TM6000_INPUT_COMPOSITE1] = "Composite 1",
 
1091
        [TM6000_INPUT_COMPOSITE2] = "Composite 2",
 
1092
        [TM6000_INPUT_SVIDEO] = "S-Video",
 
1093
};
 
1094
 
 
1095
static int vidioc_enum_input(struct file *file, void *priv,
 
1096
                                struct v4l2_input *i)
 
1097
{
 
1098
        struct tm6000_fh   *fh = priv;
 
1099
        struct tm6000_core *dev = fh->dev;
 
1100
        unsigned int n;
 
1101
 
 
1102
        n = i->index;
 
1103
        if (n >= 3)
 
1104
                return -EINVAL;
 
1105
 
 
1106
        if (!dev->vinput[n].type)
 
1107
                return -EINVAL;
 
1108
 
 
1109
        i->index = n;
 
1110
 
 
1111
        if (dev->vinput[n].type == TM6000_INPUT_TV)
 
1112
                i->type = V4L2_INPUT_TYPE_TUNER;
 
1113
        else
 
1114
                i->type = V4L2_INPUT_TYPE_CAMERA;
 
1115
 
 
1116
        strcpy(i->name, iname[dev->vinput[n].type]);
 
1117
 
 
1118
        i->std = TM6000_STD;
 
1119
 
 
1120
        return 0;
 
1121
}
 
1122
 
 
1123
static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 
1124
{
 
1125
        struct tm6000_fh   *fh = priv;
 
1126
        struct tm6000_core *dev = fh->dev;
 
1127
 
 
1128
        *i = dev->input;
 
1129
 
 
1130
        return 0;
 
1131
}
 
1132
 
 
1133
static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 
1134
{
 
1135
        struct tm6000_fh   *fh = priv;
 
1136
        struct tm6000_core *dev = fh->dev;
 
1137
        int rc = 0;
 
1138
 
 
1139
        if (i >= 3)
 
1140
                return -EINVAL;
 
1141
        if (!dev->vinput[i].type)
 
1142
                return -EINVAL;
 
1143
 
 
1144
        dev->input = i;
 
1145
 
 
1146
        rc = vidioc_s_std(file, priv, &dev->vfd->current_norm);
 
1147
 
 
1148
        return rc;
 
1149
}
 
1150
 
 
1151
/* --- controls ---------------------------------------------- */
 
1152
static int vidioc_queryctrl(struct file *file, void *priv,
 
1153
                                struct v4l2_queryctrl *qc)
 
1154
{
 
1155
        int i;
 
1156
 
 
1157
        for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
 
1158
                if (qc->id && qc->id == tm6000_qctrl[i].id) {
 
1159
                        memcpy(qc, &(tm6000_qctrl[i]),
 
1160
                                sizeof(*qc));
 
1161
                        return 0;
 
1162
                }
 
1163
 
 
1164
        return -EINVAL;
 
1165
}
 
1166
 
 
1167
static int vidioc_g_ctrl(struct file *file, void *priv,
 
1168
                                struct v4l2_control *ctrl)
 
1169
{
 
1170
        struct tm6000_fh  *fh = priv;
 
1171
        struct tm6000_core *dev    = fh->dev;
 
1172
        int  val;
 
1173
 
 
1174
        /* FIXME: Probably, those won't work! Maybe we need shadow regs */
 
1175
        switch (ctrl->id) {
 
1176
        case V4L2_CID_CONTRAST:
 
1177
                val = tm6000_get_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, 0);
 
1178
                break;
 
1179
        case V4L2_CID_BRIGHTNESS:
 
1180
                val = tm6000_get_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, 0);
 
1181
                return 0;
 
1182
        case V4L2_CID_SATURATION:
 
1183
                val = tm6000_get_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, 0);
 
1184
                return 0;
 
1185
        case V4L2_CID_HUE:
 
1186
                val = tm6000_get_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, 0);
 
1187
                return 0;
 
1188
        case V4L2_CID_AUDIO_MUTE:
 
1189
                val = dev->ctl_mute;
 
1190
                return 0;
 
1191
        case V4L2_CID_AUDIO_VOLUME:
 
1192
                val = dev->ctl_volume;
 
1193
                return 0;
 
1194
        default:
 
1195
                return -EINVAL;
 
1196
        }
 
1197
 
 
1198
        if (val < 0)
 
1199
                return val;
 
1200
 
 
1201
        ctrl->value = val;
 
1202
 
 
1203
        return 0;
 
1204
}
 
1205
static int vidioc_s_ctrl(struct file *file, void *priv,
 
1206
                                struct v4l2_control *ctrl)
 
1207
{
 
1208
        struct tm6000_fh   *fh  = priv;
 
1209
        struct tm6000_core *dev = fh->dev;
 
1210
        u8  val = ctrl->value;
 
1211
 
 
1212
        switch (ctrl->id) {
 
1213
        case V4L2_CID_CONTRAST:
 
1214
                tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val);
 
1215
                return 0;
 
1216
        case V4L2_CID_BRIGHTNESS:
 
1217
                tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val);
 
1218
                return 0;
 
1219
        case V4L2_CID_SATURATION:
 
1220
                tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val);
 
1221
                return 0;
 
1222
        case V4L2_CID_HUE:
 
1223
                tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val);
 
1224
                return 0;
 
1225
        case V4L2_CID_AUDIO_MUTE:
 
1226
                dev->ctl_mute = val;
 
1227
                tm6000_tvaudio_set_mute(dev, val);
 
1228
                return 0;
 
1229
        case V4L2_CID_AUDIO_VOLUME:
 
1230
                dev->ctl_volume = val;
 
1231
                tm6000_set_volume(dev, val);
 
1232
                return 0;
 
1233
        }
 
1234
        return -EINVAL;
 
1235
}
 
1236
 
 
1237
static int vidioc_g_tuner(struct file *file, void *priv,
 
1238
                                struct v4l2_tuner *t)
 
1239
{
 
1240
        struct tm6000_fh   *fh  = priv;
 
1241
        struct tm6000_core *dev = fh->dev;
 
1242
 
 
1243
        if (unlikely(UNSET == dev->tuner_type))
 
1244
                return -EINVAL;
 
1245
        if (0 != t->index)
 
1246
                return -EINVAL;
 
1247
 
 
1248
        strcpy(t->name, "Television");
 
1249
        t->type       = V4L2_TUNER_ANALOG_TV;
 
1250
        t->capability = V4L2_TUNER_CAP_NORM;
 
1251
        t->rangehigh  = 0xffffffffUL;
 
1252
        t->rxsubchans = V4L2_TUNER_SUB_STEREO;
 
1253
 
 
1254
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
 
1255
 
 
1256
        t->audmode = dev->amode;
 
1257
 
 
1258
        return 0;
 
1259
}
 
1260
 
 
1261
static int vidioc_s_tuner(struct file *file, void *priv,
 
1262
                                struct v4l2_tuner *t)
 
1263
{
 
1264
        struct tm6000_fh   *fh  = priv;
 
1265
        struct tm6000_core *dev = fh->dev;
 
1266
 
 
1267
        if (UNSET == dev->tuner_type)
 
1268
                return -EINVAL;
 
1269
        if (0 != t->index)
 
1270
                return -EINVAL;
 
1271
 
 
1272
        dev->amode = t->audmode;
 
1273
        dprintk(dev, 3, "audio mode: %x\n", t->audmode);
 
1274
 
 
1275
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
 
1276
 
 
1277
        return 0;
 
1278
}
 
1279
 
 
1280
static int vidioc_g_frequency(struct file *file, void *priv,
 
1281
                                struct v4l2_frequency *f)
 
1282
{
 
1283
        struct tm6000_fh   *fh  = priv;
 
1284
        struct tm6000_core *dev = fh->dev;
 
1285
 
 
1286
        if (unlikely(UNSET == dev->tuner_type))
 
1287
                return -EINVAL;
 
1288
 
 
1289
        f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
 
1290
        f->frequency = dev->freq;
 
1291
 
 
1292
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, f);
 
1293
 
 
1294
        return 0;
 
1295
}
 
1296
 
 
1297
static int vidioc_s_frequency(struct file *file, void *priv,
 
1298
                                struct v4l2_frequency *f)
 
1299
{
 
1300
        struct tm6000_fh   *fh  = priv;
 
1301
        struct tm6000_core *dev = fh->dev;
 
1302
 
 
1303
        if (unlikely(UNSET == dev->tuner_type))
 
1304
                return -EINVAL;
 
1305
        if (unlikely(f->tuner != 0))
 
1306
                return -EINVAL;
 
1307
        if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
 
1308
                return -EINVAL;
 
1309
        if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
 
1310
                return -EINVAL;
 
1311
 
 
1312
        dev->freq = f->frequency;
 
1313
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
 
1314
 
 
1315
        return 0;
 
1316
}
 
1317
 
 
1318
static int radio_querycap(struct file *file, void *priv,
 
1319
                                        struct v4l2_capability *cap)
 
1320
{
 
1321
        struct tm6000_fh *fh = file->private_data;
 
1322
        struct tm6000_core *dev = fh->dev;
 
1323
 
 
1324
        strcpy(cap->driver, "tm6000");
 
1325
        strlcpy(cap->card, dev->name, sizeof(dev->name));
 
1326
        sprintf(cap->bus_info, "USB%04x:%04x",
 
1327
                le16_to_cpu(dev->udev->descriptor.idVendor),
 
1328
                le16_to_cpu(dev->udev->descriptor.idProduct));
 
1329
        cap->version = dev->dev_type;
 
1330
        cap->capabilities = V4L2_CAP_TUNER |
 
1331
                        V4L2_CAP_AUDIO     |
 
1332
                        V4L2_CAP_RADIO     |
 
1333
                        V4L2_CAP_READWRITE |
 
1334
                        V4L2_CAP_STREAMING;
 
1335
 
 
1336
        return 0;
 
1337
}
 
1338
 
 
1339
static int radio_g_tuner(struct file *file, void *priv,
 
1340
                                        struct v4l2_tuner *t)
 
1341
{
 
1342
        struct tm6000_fh *fh = file->private_data;
 
1343
        struct tm6000_core *dev = fh->dev;
 
1344
 
 
1345
        if (0 != t->index)
 
1346
                return -EINVAL;
 
1347
 
 
1348
        memset(t, 0, sizeof(*t));
 
1349
        strcpy(t->name, "Radio");
 
1350
        t->type = V4L2_TUNER_RADIO;
 
1351
        t->rxsubchans = V4L2_TUNER_SUB_STEREO;
 
1352
 
 
1353
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
 
1354
 
 
1355
        return 0;
 
1356
}
 
1357
 
 
1358
static int radio_s_tuner(struct file *file, void *priv,
 
1359
                                        struct v4l2_tuner *t)
 
1360
{
 
1361
        struct tm6000_fh *fh = file->private_data;
 
1362
        struct tm6000_core *dev = fh->dev;
 
1363
 
 
1364
        if (0 != t->index)
 
1365
                return -EINVAL;
 
1366
 
 
1367
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
 
1368
 
 
1369
        return 0;
 
1370
}
 
1371
 
 
1372
static int radio_enum_input(struct file *file, void *priv,
 
1373
                                        struct v4l2_input *i)
 
1374
{
 
1375
        struct tm6000_fh *fh = priv;
 
1376
        struct tm6000_core *dev = fh->dev;
 
1377
 
 
1378
        if (i->index != 0)
 
1379
                return -EINVAL;
 
1380
 
 
1381
        if (!dev->rinput.type)
 
1382
                return -EINVAL;
 
1383
 
 
1384
        strcpy(i->name, "Radio");
 
1385
        i->type = V4L2_INPUT_TYPE_TUNER;
 
1386
 
 
1387
        return 0;
 
1388
}
 
1389
 
 
1390
static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
 
1391
{
 
1392
        struct tm6000_fh *fh = priv;
 
1393
        struct tm6000_core *dev = fh->dev;
 
1394
 
 
1395
        if (dev->input != 5)
 
1396
                return -EINVAL;
 
1397
 
 
1398
        *i = dev->input - 5;
 
1399
 
 
1400
        return 0;
 
1401
}
 
1402
 
 
1403
static int radio_g_audio(struct file *file, void *priv,
 
1404
                                        struct v4l2_audio *a)
 
1405
{
 
1406
        memset(a, 0, sizeof(*a));
 
1407
        strcpy(a->name, "Radio");
 
1408
        return 0;
 
1409
}
 
1410
 
 
1411
static int radio_s_audio(struct file *file, void *priv,
 
1412
                                        struct v4l2_audio *a)
 
1413
{
 
1414
        return 0;
 
1415
}
 
1416
 
 
1417
static int radio_s_input(struct file *filp, void *priv, unsigned int i)
 
1418
{
 
1419
        struct tm6000_fh *fh = priv;
 
1420
        struct tm6000_core *dev = fh->dev;
 
1421
 
 
1422
        if (i)
 
1423
                return -EINVAL;
 
1424
 
 
1425
        if (!dev->rinput.type)
 
1426
                return -EINVAL;
 
1427
 
 
1428
        dev->input = i + 5;
 
1429
 
 
1430
        return 0;
 
1431
}
 
1432
 
 
1433
static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
 
1434
{
 
1435
        return 0;
 
1436
}
 
1437
 
 
1438
static int radio_queryctrl(struct file *file, void *priv,
 
1439
                                        struct v4l2_queryctrl *c)
 
1440
{
 
1441
        const struct v4l2_queryctrl *ctrl;
 
1442
 
 
1443
        if (c->id <  V4L2_CID_BASE ||
 
1444
            c->id >= V4L2_CID_LASTP1)
 
1445
                return -EINVAL;
 
1446
        if (c->id == V4L2_CID_AUDIO_MUTE) {
 
1447
                ctrl = ctrl_by_id(c->id);
 
1448
                *c = *ctrl;
 
1449
        } else
 
1450
                *c = no_ctrl;
 
1451
 
 
1452
        return 0;
 
1453
}
 
1454
 
 
1455
/* ------------------------------------------------------------------
 
1456
        File operations for the device
 
1457
   ------------------------------------------------------------------*/
 
1458
 
 
1459
static int tm6000_open(struct file *file)
 
1460
{
 
1461
        struct video_device *vdev = video_devdata(file);
 
1462
        struct tm6000_core *dev = video_drvdata(file);
 
1463
        struct tm6000_fh *fh;
 
1464
        enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
1465
        int i, rc;
 
1466
        int radio = 0;
 
1467
 
 
1468
        dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: open called (dev=%s)\n",
 
1469
                video_device_node_name(vdev));
 
1470
 
 
1471
        switch (vdev->vfl_type) {
 
1472
        case VFL_TYPE_GRABBER:
 
1473
                type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
1474
                break;
 
1475
        case VFL_TYPE_VBI:
 
1476
                type = V4L2_BUF_TYPE_VBI_CAPTURE;
 
1477
                break;
 
1478
        case VFL_TYPE_RADIO:
 
1479
                radio = 1;
 
1480
                break;
 
1481
        }
 
1482
 
 
1483
        /* If more than one user, mutex should be added */
 
1484
        dev->users++;
 
1485
 
 
1486
        dprintk(dev, V4L2_DEBUG_OPEN, "open dev=%s type=%s users=%d\n",
 
1487
                video_device_node_name(vdev), v4l2_type_names[type],
 
1488
                dev->users);
 
1489
 
 
1490
        /* allocate + initialize per filehandle data */
 
1491
        fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 
1492
        if (NULL == fh) {
 
1493
                dev->users--;
 
1494
                return -ENOMEM;
 
1495
        }
 
1496
 
 
1497
        file->private_data = fh;
 
1498
        fh->dev      = dev;
 
1499
        fh->radio    = radio;
 
1500
        dev->radio   = radio;
 
1501
        fh->type     = type;
 
1502
        dev->fourcc  = format[0].fourcc;
 
1503
 
 
1504
        fh->fmt      = format_by_fourcc(dev->fourcc);
 
1505
 
 
1506
        tm6000_get_std_res(dev);
 
1507
 
 
1508
        fh->width = dev->width;
 
1509
        fh->height = dev->height;
 
1510
 
 
1511
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: fh=0x%08lx, dev=0x%08lx, "
 
1512
                                                "dev->vidq=0x%08lx\n",
 
1513
                        (unsigned long)fh, (unsigned long)dev,
 
1514
                        (unsigned long)&dev->vidq);
 
1515
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
 
1516
                                "queued=%d\n", list_empty(&dev->vidq.queued));
 
1517
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
 
1518
                                "active=%d\n", list_empty(&dev->vidq.active));
 
1519
 
 
1520
        /* initialize hardware on analog mode */
 
1521
        rc = tm6000_init_analog_mode(dev);
 
1522
        if (rc < 0)
 
1523
                return rc;
 
1524
 
 
1525
        if (dev->mode != TM6000_MODE_ANALOG) {
 
1526
                /* Put all controls at a sane state */
 
1527
                for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
 
1528
                        qctl_regs[i] = tm6000_qctrl[i].default_value;
 
1529
 
 
1530
                dev->mode = TM6000_MODE_ANALOG;
 
1531
        }
 
1532
 
 
1533
        if (!fh->radio) {
 
1534
                videobuf_queue_vmalloc_init(&fh->vb_vidq, &tm6000_video_qops,
 
1535
                                NULL, &dev->slock,
 
1536
                                fh->type,
 
1537
                                V4L2_FIELD_INTERLACED,
 
1538
                                sizeof(struct tm6000_buffer), fh, &dev->lock);
 
1539
        } else {
 
1540
                dprintk(dev, V4L2_DEBUG_OPEN, "video_open: setting radio device\n");
 
1541
                dev->input = 5;
 
1542
                tm6000_set_audio_rinput(dev);
 
1543
                v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
 
1544
                tm6000_prepare_isoc(dev);
 
1545
                tm6000_start_thread(dev);
 
1546
        }
 
1547
 
 
1548
        return 0;
 
1549
}
 
1550
 
 
1551
static ssize_t
 
1552
tm6000_read(struct file *file, char __user *data, size_t count, loff_t *pos)
 
1553
{
 
1554
        struct tm6000_fh        *fh = file->private_data;
 
1555
 
 
1556
        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 
1557
                if (!res_get(fh->dev, fh, true))
 
1558
                        return -EBUSY;
 
1559
 
 
1560
                return videobuf_read_stream(&fh->vb_vidq, data, count, pos, 0,
 
1561
                                        file->f_flags & O_NONBLOCK);
 
1562
        }
 
1563
        return 0;
 
1564
}
 
1565
 
 
1566
static unsigned int
 
1567
tm6000_poll(struct file *file, struct poll_table_struct *wait)
 
1568
{
 
1569
        struct tm6000_fh        *fh = file->private_data;
 
1570
        struct tm6000_buffer    *buf;
 
1571
 
 
1572
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
 
1573
                return POLLERR;
 
1574
 
 
1575
        if (!!is_res_streaming(fh->dev, fh))
 
1576
                return POLLERR;
 
1577
 
 
1578
        if (!is_res_read(fh->dev, fh)) {
 
1579
                /* streaming capture */
 
1580
                if (list_empty(&fh->vb_vidq.stream))
 
1581
                        return POLLERR;
 
1582
                buf = list_entry(fh->vb_vidq.stream.next, struct tm6000_buffer, vb.stream);
 
1583
        } else {
 
1584
                /* read() capture */
 
1585
                return videobuf_poll_stream(file, &fh->vb_vidq, wait);
 
1586
        }
 
1587
        poll_wait(file, &buf->vb.done, wait);
 
1588
        if (buf->vb.state == VIDEOBUF_DONE ||
 
1589
            buf->vb.state == VIDEOBUF_ERROR)
 
1590
                return POLLIN | POLLRDNORM;
 
1591
        return 0;
 
1592
}
 
1593
 
 
1594
static int tm6000_release(struct file *file)
 
1595
{
 
1596
        struct tm6000_fh         *fh = file->private_data;
 
1597
        struct tm6000_core      *dev = fh->dev;
 
1598
        struct video_device    *vdev = video_devdata(file);
 
1599
 
 
1600
        dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: close called (dev=%s, users=%d)\n",
 
1601
                video_device_node_name(vdev), dev->users);
 
1602
 
 
1603
        dev->users--;
 
1604
 
 
1605
        res_free(dev, fh);
 
1606
 
 
1607
        if (!dev->users) {
 
1608
                int err;
 
1609
 
 
1610
                tm6000_uninit_isoc(dev);
 
1611
 
 
1612
                if (!fh->radio)
 
1613
                        videobuf_mmap_free(&fh->vb_vidq);
 
1614
 
 
1615
                err = tm6000_reset(dev);
 
1616
                if (err < 0)
 
1617
                        dev_err(&vdev->dev, "reset failed: %d\n", err);
 
1618
        }
 
1619
 
 
1620
        kfree(fh);
 
1621
 
 
1622
        return 0;
 
1623
}
 
1624
 
 
1625
static int tm6000_mmap(struct file *file, struct vm_area_struct * vma)
 
1626
{
 
1627
        struct tm6000_fh *fh = file->private_data;
 
1628
 
 
1629
        return videobuf_mmap_mapper(&fh->vb_vidq, vma);
 
1630
}
 
1631
 
 
1632
static struct v4l2_file_operations tm6000_fops = {
 
1633
        .owner = THIS_MODULE,
 
1634
        .open = tm6000_open,
 
1635
        .release = tm6000_release,
 
1636
        .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
 
1637
        .read = tm6000_read,
 
1638
        .poll = tm6000_poll,
 
1639
        .mmap = tm6000_mmap,
 
1640
};
 
1641
 
 
1642
static const struct v4l2_ioctl_ops video_ioctl_ops = {
 
1643
        .vidioc_querycap          = vidioc_querycap,
 
1644
        .vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
 
1645
        .vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
 
1646
        .vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
 
1647
        .vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
 
1648
        .vidioc_s_std             = vidioc_s_std,
 
1649
        .vidioc_enum_input        = vidioc_enum_input,
 
1650
        .vidioc_g_input           = vidioc_g_input,
 
1651
        .vidioc_s_input           = vidioc_s_input,
 
1652
        .vidioc_queryctrl         = vidioc_queryctrl,
 
1653
        .vidioc_g_ctrl            = vidioc_g_ctrl,
 
1654
        .vidioc_s_ctrl            = vidioc_s_ctrl,
 
1655
        .vidioc_g_tuner           = vidioc_g_tuner,
 
1656
        .vidioc_s_tuner           = vidioc_s_tuner,
 
1657
        .vidioc_g_frequency       = vidioc_g_frequency,
 
1658
        .vidioc_s_frequency       = vidioc_s_frequency,
 
1659
        .vidioc_streamon          = vidioc_streamon,
 
1660
        .vidioc_streamoff         = vidioc_streamoff,
 
1661
        .vidioc_reqbufs           = vidioc_reqbufs,
 
1662
        .vidioc_querybuf          = vidioc_querybuf,
 
1663
        .vidioc_qbuf              = vidioc_qbuf,
 
1664
        .vidioc_dqbuf             = vidioc_dqbuf,
 
1665
};
 
1666
 
 
1667
static struct video_device tm6000_template = {
 
1668
        .name           = "tm6000",
 
1669
        .fops           = &tm6000_fops,
 
1670
        .ioctl_ops      = &video_ioctl_ops,
 
1671
        .release        = video_device_release,
 
1672
        .tvnorms        = TM6000_STD,
 
1673
        .current_norm   = V4L2_STD_NTSC_M,
 
1674
};
 
1675
 
 
1676
static const struct v4l2_file_operations radio_fops = {
 
1677
        .owner          = THIS_MODULE,
 
1678
        .open           = tm6000_open,
 
1679
        .release        = tm6000_release,
 
1680
        .unlocked_ioctl = video_ioctl2,
 
1681
};
 
1682
 
 
1683
static const struct v4l2_ioctl_ops radio_ioctl_ops = {
 
1684
        .vidioc_querycap        = radio_querycap,
 
1685
        .vidioc_g_tuner         = radio_g_tuner,
 
1686
        .vidioc_enum_input      = radio_enum_input,
 
1687
        .vidioc_g_audio         = radio_g_audio,
 
1688
        .vidioc_s_tuner         = radio_s_tuner,
 
1689
        .vidioc_s_audio         = radio_s_audio,
 
1690
        .vidioc_s_input         = radio_s_input,
 
1691
        .vidioc_s_std           = radio_s_std,
 
1692
        .vidioc_queryctrl       = radio_queryctrl,
 
1693
        .vidioc_g_input         = radio_g_input,
 
1694
        .vidioc_g_ctrl          = vidioc_g_ctrl,
 
1695
        .vidioc_s_ctrl          = vidioc_s_ctrl,
 
1696
        .vidioc_g_frequency     = vidioc_g_frequency,
 
1697
        .vidioc_s_frequency     = vidioc_s_frequency,
 
1698
};
 
1699
 
 
1700
static struct video_device tm6000_radio_template = {
 
1701
        .name                   = "tm6000",
 
1702
        .fops                   = &radio_fops,
 
1703
        .ioctl_ops              = &radio_ioctl_ops,
 
1704
};
 
1705
 
 
1706
/* -----------------------------------------------------------------
 
1707
 *      Initialization and module stuff
 
1708
 * ------------------------------------------------------------------
 
1709
 */
 
1710
 
 
1711
static struct video_device *vdev_init(struct tm6000_core *dev,
 
1712
                const struct video_device
 
1713
                *template, const char *type_name)
 
1714
{
 
1715
        struct video_device *vfd;
 
1716
 
 
1717
        vfd = video_device_alloc();
 
1718
        if (NULL == vfd)
 
1719
                return NULL;
 
1720
 
 
1721
        *vfd = *template;
 
1722
        vfd->v4l2_dev = &dev->v4l2_dev;
 
1723
        vfd->release = video_device_release;
 
1724
        vfd->debug = tm6000_debug;
 
1725
        vfd->lock = &dev->lock;
 
1726
 
 
1727
        snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
 
1728
 
 
1729
        video_set_drvdata(vfd, dev);
 
1730
        return vfd;
 
1731
}
 
1732
 
 
1733
int tm6000_v4l2_register(struct tm6000_core *dev)
 
1734
{
 
1735
        int ret = -1;
 
1736
 
 
1737
        dev->vfd = vdev_init(dev, &tm6000_template, "video");
 
1738
 
 
1739
        if (!dev->vfd) {
 
1740
                printk(KERN_INFO "%s: can't register video device\n",
 
1741
                       dev->name);
 
1742
                return -ENOMEM;
 
1743
        }
 
1744
 
 
1745
        /* init video dma queues */
 
1746
        INIT_LIST_HEAD(&dev->vidq.active);
 
1747
        INIT_LIST_HEAD(&dev->vidq.queued);
 
1748
 
 
1749
        ret = video_register_device(dev->vfd, VFL_TYPE_GRABBER, video_nr);
 
1750
 
 
1751
        if (ret < 0) {
 
1752
                printk(KERN_INFO "%s: can't register video device\n",
 
1753
                       dev->name);
 
1754
                return ret;
 
1755
        }
 
1756
 
 
1757
        printk(KERN_INFO "%s: registered device %s\n",
 
1758
               dev->name, video_device_node_name(dev->vfd));
 
1759
 
 
1760
        if (dev->caps.has_radio) {
 
1761
                dev->radio_dev = vdev_init(dev, &tm6000_radio_template,
 
1762
                                                           "radio");
 
1763
                if (!dev->radio_dev) {
 
1764
                        printk(KERN_INFO "%s: can't register radio device\n",
 
1765
                               dev->name);
 
1766
                        return ret; /* FIXME release resource */
 
1767
                }
 
1768
 
 
1769
                ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
 
1770
                                            radio_nr);
 
1771
                if (ret < 0) {
 
1772
                        printk(KERN_INFO "%s: can't register radio device\n",
 
1773
                               dev->name);
 
1774
                        return ret; /* FIXME release resource */
 
1775
                }
 
1776
 
 
1777
                printk(KERN_INFO "%s: registered device %s\n",
 
1778
                       dev->name, video_device_node_name(dev->radio_dev));
 
1779
        }
 
1780
 
 
1781
        printk(KERN_INFO "Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load status: %d)\n", ret);
 
1782
        return ret;
 
1783
}
 
1784
 
 
1785
int tm6000_v4l2_unregister(struct tm6000_core *dev)
 
1786
{
 
1787
        video_unregister_device(dev->vfd);
 
1788
 
 
1789
        if (dev->radio_dev) {
 
1790
                if (video_is_registered(dev->radio_dev))
 
1791
                        video_unregister_device(dev->radio_dev);
 
1792
                else
 
1793
                        video_device_release(dev->radio_dev);
 
1794
                dev->radio_dev = NULL;
 
1795
        }
 
1796
 
 
1797
        return 0;
 
1798
}
 
1799
 
 
1800
int tm6000_v4l2_exit(void)
 
1801
{
 
1802
        return 0;
 
1803
}
 
1804
 
 
1805
module_param(video_nr, int, 0);
 
1806
MODULE_PARM_DESC(video_nr, "Allow changing video device number");
 
1807
 
 
1808
module_param_named(debug, tm6000_debug, int, 0444);
 
1809
MODULE_PARM_DESC(debug, "activates debug info");
 
1810
 
 
1811
module_param(vid_limit, int, 0644);
 
1812
MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
 
1813