em28xx-video.c 52.2 KB
Newer Older
1
/*
2
   em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
3

4
5
   Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
		      Markus Rechberger <mrechberger@gmail.com>
6
		      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
7
		      Sascha Sommer <saschasommer@freenet.de>
8

9
10
11
	Some parts based on SN9C10x PC Camera Controllers GPL driver made
		by Luca Risolia <luca.risolia@studio.unibo.it>

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
31
#include <linux/bitmap.h>
32
33
#include <linux/usb.h>
#include <linux/i2c.h>
34
#include <linux/version.h>
35
#include <linux/video_decoder.h>
36
#include <linux/mutex.h>
37

38
#include "em28xx.h"
39
#include <media/tuner.h>
40
#include <media/v4l2-common.h>
41

42
43
44
45
#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
		      "Markus Rechberger <mrechberger@gmail.com>, " \
		      "Mauro Carvalho Chehab <mchehab@brturbo.com.br>, " \
		      "Sascha Sommer <saschasommer@freenet.de>"
46

47
48
#define DRIVER_NAME         "em28xx"
#define DRIVER_DESC         "Empia em28xx based USB video device driver"
49
#define EM28XX_VERSION_CODE  KERNEL_VERSION(0, 0, 1)
50

51
#define em28xx_videodbg(fmt, arg...) do {\
52
53
	if (video_debug) \
		printk(KERN_INFO "%s %s :"fmt, \
54
			 dev->name, __FUNCTION__ , ##arg); } while (0)
55
56
57
58
59

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

60
static LIST_HEAD(em28xx_devlist);
61

62
static unsigned int card[]     = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
63
64
static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
65
module_param_array(card,  int, NULL, 0444);
66
67
module_param_array(video_nr, int, NULL, 0444);
module_param_array(vbi_nr, int, NULL, 0444);
68
MODULE_PARM_DESC(card,"card type");
69
70
MODULE_PARM_DESC(video_nr,"video device numbers");
MODULE_PARM_DESC(vbi_nr,"vbi device numbers");
71

72
73
74
75
76
77
78
79
static int tuner = -1;
module_param(tuner, int, 0444);
MODULE_PARM_DESC(tuner, "tuner type");

static unsigned int video_debug = 0;
module_param(video_debug,int,0644);
MODULE_PARM_DESC(video_debug,"enable debug messages [video]");

80
81
82
/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
static unsigned long em28xx_devused;

83
/* supported tv norms */
84
static struct em28xx_tvnorm tvnorms[] = {
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
	{
		.name = "PAL",
		.id = V4L2_STD_PAL,
		.mode = VIDEO_MODE_PAL,
	 }, {
		.name = "NTSC",
		.id = V4L2_STD_NTSC,
		.mode = VIDEO_MODE_NTSC,
	}, {
		 .name = "SECAM",
		 .id = V4L2_STD_SECAM,
		 .mode = VIDEO_MODE_SECAM,
	}, {
		.name = "PAL-M",
		.id = V4L2_STD_PAL_M,
		.mode = VIDEO_MODE_PAL,
	}
};

104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
static const unsigned char saa7114_i2c_init[] = {
	0x00,0x00,0x01,0x08,0x02,0xc4,0x03,0x30,0x04,0x90,0x05,0x90,0x06,0xeb,0x07,0xe0,
	0x08,0x88,0x09,0x40,0x0a,0x80,0x0b,0x44,0x0c,0x40,0x0d,0x00,0x0e,0x81,0x0f,0x2a,
	0x10,0x06,0x11,0x00,0x12,0xc8,0x13,0x80,0x14,0x00,0x15,0x11,0x16,0x01,0x17,0x42,
	0x18,0x40,0x19,0x80,0x40,0x00,0x41,0xff,0x42,0xff,0x43,0xff,0x44,0xff,0x45,0xff,
	0x46,0xff,0x47,0xff,0x48,0xff,0x49,0xff,0x4a,0xff,0x4b,0xff,0x4c,0xff,0x4d,0xff,
	0x4e,0xff,0x4f,0xff,0x50,0xff,0x51,0xff,0x52,0xff,0x53,0xff,0x54,0x5f,0x55,0xff,
	0x56,0xff,0x57,0xff,0x58,0x00,0x59,0x47,0x5a,0x03,0x5b,0x03,0x5d,0x3e,0x5e,0x00,
	0x80,0x1c,0x83,0x01,0x84,0xa5,0x85,0x10,0x86,0x45,0x87,0x41,0x88,0xf0,0x88,0x00,
	0x88,0xf0,0x90,0x00,0x91,0x08,0x92,0x00,0x93,0x80,0x94,0x08,0x95,0x00,0x96,0xc0,
	0x97,0x02,0x98,0x13,0x99,0x00,0x9a,0x38,0x9b,0x01,0x9c,0x80,0x9d,0x02,0x9e,0x06,
	0x9f,0x01,0xa0,0x01,0xa1,0x00,0xa2,0x00,0xa4,0x80,0xa5,0x36,0xa6,0x36,0xa8,0x67,
	0xa9,0x04,0xaa,0x00,0xac,0x33,0xad,0x02,0xae,0x00,0xb0,0xcd,0xb1,0x04,0xb2,0xcd,
	0xb3,0x04,0xb4,0x01,0xb8,0x00,0xb9,0x00,0xba,0x00,0xbb,0x00,0xbc,0x00,0xbd,0x00,
	0xbe,0x00,0xbf,0x00
};

121
122
123
#define TVNORMS ARRAY_SIZE(tvnorms)

/* supported controls */
124
/* Common to all boards */
125
static struct v4l2_queryctrl em28xx_qctrl[] = {
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
	{
		.id = V4L2_CID_AUDIO_VOLUME,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Volume",
		.minimum = 0x0,
		.maximum = 0x1f,
		.step = 0x1,
		.default_value = 0x1f,
		.flags = 0,
	},{
		.id = V4L2_CID_AUDIO_MUTE,
		.type = V4L2_CTRL_TYPE_BOOLEAN,
		.name = "Mute",
		.minimum = 0,
		.maximum = 1,
		.step = 1,
		.default_value = 1,
		.flags = 0,
	}
};

/* FIXME: These are specific to saa711x - should be moved to its code */
static struct v4l2_queryctrl saa711x_qctrl[] = {
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
	{
		.id = V4L2_CID_BRIGHTNESS,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Brightness",
		.minimum = -128,
		.maximum = 127,
		.step = 1,
		.default_value = 0,
		.flags = 0,
	},{
		.id = V4L2_CID_CONTRAST,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Contrast",
		.minimum = 0x0,
		.maximum = 0x1f,
		.step = 0x1,
		.default_value = 0x10,
		.flags = 0,
	},{
		.id = V4L2_CID_SATURATION,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Saturation",
		.minimum = 0x0,
		.maximum = 0x1f,
		.step = 0x1,
		.default_value = 0x10,
		.flags = 0,
	},{
		.id = V4L2_CID_RED_BALANCE,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Red chroma balance",
		.minimum = -128,
		.maximum = 127,
		.step = 1,
		.default_value = 0,
		.flags = 0,
	},{
		.id = V4L2_CID_BLUE_BALANCE,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Blue chroma balance",
		.minimum = -128,
		.maximum = 127,
		.step = 1,
		.default_value = 0,
		.flags = 0,
	},{
		.id = V4L2_CID_GAMMA,
		.type = V4L2_CTRL_TYPE_INTEGER,
		.name = "Gamma",
		.minimum = 0x0,
		.maximum = 0x3f,
		.step = 0x1,
		.default_value = 0x20,
		.flags = 0,
203
	}
204
205
};

206
static struct usb_driver em28xx_usb_driver;
207

208
static DEFINE_MUTEX(em28xx_sysfs_lock);
209
static DECLARE_RWSEM(em28xx_disconnect);
210
211
212
213

/*********************  v4l2 interface  ******************************************/

/*
214
 * em28xx_config()
215
216
 * inits registers with sane defaults
 */
217
static int em28xx_config(struct em28xx *dev)
218
219
220
{

	/* Sets I2C speed to 100 KHz */
221
	em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1);
222
223

	/* enable vbi capturing */
224

225
226
/*	em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */
/*	em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */
227
228
	em28xx_write_regs_req(dev,0x00,0x11,"\x51",1);

229
	em28xx_audio_usb_mute(dev, 1);
230
231
	dev->mute = 1;		/* maybe not the right place... */
	dev->volume = 0x1f;
232
233
234
235
236
	em28xx_audio_analog_set(dev);
	em28xx_audio_analog_setup(dev);
	em28xx_outfmt_set_yuv422(dev);
	em28xx_colorlevels_set_default(dev);
	em28xx_compression_disable(dev);
237
238
239
240
241

	return 0;
}

/*
242
 * em28xx_config_i2c()
243
244
 * configure i2c attached devices
 */
245
static void em28xx_config_i2c(struct em28xx *dev)
246
247
{
	struct v4l2_frequency f;
248
	struct video_decoder_init em28xx_vdi = {.data = NULL };
249
250
251


	/* configure decoder */
252
	if(dev->model == EM2820_BOARD_MSI_VOX_USB_2){
253
254
		em28xx_vdi.data=saa7114_i2c_init;
		em28xx_vdi.len=sizeof(saa7114_i2c_init);
255
256
257
	}


258
259
260
261
262
263
	em28xx_i2c_call_clients(dev, DECODER_INIT, &em28xx_vdi);
	em28xx_i2c_call_clients(dev, DECODER_SET_INPUT, &dev->ctl_input);
/*	em28xx_i2c_call_clients(dev,DECODER_SET_PICTURE, &dev->vpic); */
/*	em28xx_i2c_call_clients(dev,DECODER_SET_NORM,&dev->tvnorm->id); */
/*	em28xx_i2c_call_clients(dev,DECODER_ENABLE_OUTPUT,&output); */
/*	em28xx_i2c_call_clients(dev,DECODER_DUMP, NULL); */
264
265
266
267
268
269

	/* configure tuner */
	f.tuner = 0;
	f.type = V4L2_TUNER_ANALOG_TV;
	f.frequency = 9076;	/* FIXME:remove magic number */
	dev->ctl_freq = f.frequency;
270
	em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, &f);
271
272
273
274

	/* configure tda9887 */


275
/*	em28xx_i2c_call_clients(dev,VIDIOC_S_STD,&dev->tvnorm->id); */
276
277
278
}

/*
279
 * em28xx_empty_framequeues()
280
281
 * prepare queues for incoming and outgoing frames
 */
282
static void em28xx_empty_framequeues(struct em28xx *dev)
283
284
285
286
287
288
{
	u32 i;

	INIT_LIST_HEAD(&dev->inqueue);
	INIT_LIST_HEAD(&dev->outqueue);

289
	for (i = 0; i < EM28XX_NUM_FRAMES; i++) {
290
291
292
293
294
		dev->frame[i].state = F_UNUSED;
		dev->frame[i].buf.bytesused = 0;
	}
}

295
296
297
298
299
300
301
302
303
304
305
306
307
308
static void video_mux(struct em28xx *dev, int index)
{
	int input, ainput;

	input = INPUT(index)->vmux;
	dev->ctl_input = index;
	dev->ctl_ainput = INPUT(index)->amux;

	em28xx_i2c_call_clients(dev, DECODER_SET_INPUT, &input);


	em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,input,dev->ctl_ainput);

	if (dev->has_msp34xx) {
309
310
		if (dev->i2s_speed)
			em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ, &dev->i2s_speed);
311
312
313
314
315
		em28xx_i2c_call_clients(dev, VIDIOC_S_AUDIO, &dev->ctl_ainput);
		ainput = EM28XX_AUDIO_SRC_TUNER;
		em28xx_audio_source(dev, ainput);
	} else {
		switch (dev->ctl_ainput) {
316
317
318
319
320
			case 0:
				ainput = EM28XX_AUDIO_SRC_TUNER;
				break;
			default:
				ainput = EM28XX_AUDIO_SRC_LINE;
321
322
323
324
325
		}
		em28xx_audio_source(dev, ainput);
	}
}

326
/*
327
 * em28xx_v4l2_open()
328
329
 * inits the device and starts isoc transfer
 */
330
static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
331
332
333
{
	int minor = iminor(inode);
	int errCode = 0;
334
	struct em28xx *h,*dev = NULL;
335
336
	struct list_head *list;

337
338
	list_for_each(list,&em28xx_devlist) {
		h = list_entry(list, struct em28xx, devlist);
339
340
		if (h->vdev->minor == minor) {
			dev  = h;
341
342
343
344
345
			dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		}
		if (h->vbi_dev->minor == minor) {
			dev  = h;
			dev->type = V4L2_BUF_TYPE_VBI_CAPTURE;
346
347
		}
	}
348
349
	if (NULL == dev)
		return -ENODEV;
350
351
352

	filp->private_data=dev;

353
354
	em28xx_videodbg("open minor=%d type=%s users=%d\n",
				minor,v4l2_type_names[dev->type],dev->users);
355

356
	if (!down_read_trylock(&em28xx_disconnect))
357
358
359
		return -ERESTARTSYS;

	if (dev->users) {
360
361
		em28xx_warn("this driver can be opened only once\n");
		up_read(&em28xx_disconnect);
362
363
364
		return -EBUSY;
	}

365
	mutex_init(&dev->fileop_lock);	/* to 1 == available */
366
367
368
369
	spin_lock_init(&dev->queue_lock);
	init_waitqueue_head(&dev->wait_frame);
	init_waitqueue_head(&dev->wait_stream);

370
	mutex_lock(&dev->lock);
371

372
373
	if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
		em28xx_set_alternate(dev);
374

375
376
377
378
379
380
381
		dev->width = norm_maxw(dev);
		dev->height = norm_maxh(dev);
		dev->frame_size = dev->width * dev->height * 2;
		dev->field_size = dev->frame_size >> 1;	/*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
		dev->bytesperline = dev->width * 2;
		dev->hscale = 0;
		dev->vscale = 0;
382

383
384
		em28xx_capture_start(dev, 1);
		em28xx_resolution_set(dev);
385

386
387
388
		/* device needs to be initialized before isoc transfer */
		video_mux(dev, 0);

389
390
391
392
393
394
		/* start the transfer */
		errCode = em28xx_init_isoc(dev);
		if (errCode)
			goto err;

	}
395
396
397
398
399
400
401
402

	dev->users++;
	filp->private_data = dev;
	dev->io = IO_NONE;
	dev->stream = STREAM_OFF;
	dev->num_frames = 0;

	/* prepare queues */
403
	em28xx_empty_framequeues(dev);
404
405
406

	dev->state |= DEV_INITIALIZED;

407
408
err:
	mutex_unlock(&dev->lock);
409
	up_read(&em28xx_disconnect);
410
411
412
413
	return errCode;
}

/*
414
 * em28xx_realease_resources()
415
416
417
 * unregisters the v4l2,i2c and usb devices
 * called when the device gets disconected or at module unload
*/
418
static void em28xx_release_resources(struct em28xx *dev)
419
{
420
	mutex_lock(&em28xx_sysfs_lock);
421

422
423
424
425
426
	/*FIXME: I2C IR should be disconnected */

	em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n",
				dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
				dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN);
427
	list_del(&dev->devlist);
428
	video_unregister_device(dev->vdev);
429
	video_unregister_device(dev->vbi_dev);
430
	em28xx_i2c_unregister(dev);
431
	usb_put_dev(dev->udev);
432
	mutex_unlock(&em28xx_sysfs_lock);
433
434
435
436


	/* Mark device as unused */
	em28xx_devused&=~(1<<dev->devno);
437
438
439
}

/*
440
 * em28xx_v4l2_close()
441
442
 * stops streaming and deallocates all resources allocated by the v4l2 calls and ioctls
 */
443
static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
444
445
{
	int errCode;
446
	struct em28xx *dev=filp->private_data;
447

448
	em28xx_videodbg("users=%d\n", dev->users);
449

450
	mutex_lock(&dev->lock);
451

452
	em28xx_uninit_isoc(dev);
453

454
	em28xx_release_buffers(dev);
455
456
457

	/* the device is already disconnect, free the remaining resources */
	if (dev->state & DEV_DISCONNECTED) {
458
		em28xx_release_resources(dev);
459
		mutex_unlock(&dev->lock);
460
461
462
463
464
465
		kfree(dev);
		return 0;
	}

	/* set alternate 0 */
	dev->alt = 0;
466
	em28xx_videodbg("setting alternate 0\n");
467
468
	errCode = usb_set_interface(dev->udev, 0, 0);
	if (errCode < 0) {
469
		em28xx_errdev ("cannot change alternate number to 0 (error=%i)\n",
470
471
472
473
474
		     errCode);
	}

	dev->users--;
	wake_up_interruptible_nr(&dev->open, 1);
475
	mutex_unlock(&dev->lock);
476
477
478
479
	return 0;
}

/*
480
 * em28xx_v4l2_read()
481
482
483
 * will allocate buffers when called for the first time
 */
static ssize_t
484
em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
485
486
		 loff_t * f_pos)
{
487
	struct em28xx_frame_t *f, *i;
488
489
	unsigned long lock_flags;
	int ret = 0;
490
	struct em28xx *dev = filp->private_data;
491

492
493
494
495
496
497
498
	if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
		em28xx_videodbg("V4l2_Buf_type_videocapture is set\n");
	}
	if (dev->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
		em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n");
		em28xx_videodbg("not supported yet! ...\n");
		if (copy_to_user(buf, "", 1)) {
499
			mutex_unlock(&dev->fileop_lock);
500
501
502
503
504
505
506
507
			return -EFAULT;
		}
		return (1);
	}
	if (dev->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
		em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
		em28xx_videodbg("not supported yet! ...\n");
		if (copy_to_user(buf, "", 1)) {
508
			mutex_unlock(&dev->fileop_lock);
509
510
511
512
513
			return -EFAULT;
		}
		return (1);
	}

514
	if (mutex_lock_interruptible(&dev->fileop_lock))
515
516
517
		return -ERESTARTSYS;

	if (dev->state & DEV_DISCONNECTED) {
518
		em28xx_videodbg("device not present\n");
519
		mutex_unlock(&dev->fileop_lock);
520
521
522
523
		return -ENODEV;
	}

	if (dev->state & DEV_MISCONFIGURED) {
524
		em28xx_videodbg("device misconfigured; close and open it again\n");
525
		mutex_unlock(&dev->fileop_lock);
526
527
528
529
		return -EIO;
	}

	if (dev->io == IO_MMAP) {
530
		em28xx_videodbg ("IO method is set to mmap; close and open"
531
				" the device again to choose the read method\n");
532
		mutex_unlock(&dev->fileop_lock);
533
534
535
536
		return -EINVAL;
	}

	if (dev->io == IO_NONE) {
537
538
		if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES)) {
			em28xx_errdev("read failed, not enough memory\n");
539
			mutex_unlock(&dev->fileop_lock);
540
541
542
543
			return -ENOMEM;
		}
		dev->io = IO_READ;
		dev->stream = STREAM_ON;
544
		em28xx_queue_unusedframes(dev);
545
546
547
	}

	if (!count) {
548
		mutex_unlock(&dev->fileop_lock);
549
550
551
552
553
		return 0;
	}

	if (list_empty(&dev->outqueue)) {
		if (filp->f_flags & O_NONBLOCK) {
554
			mutex_unlock(&dev->fileop_lock);
555
556
557
558
559
560
561
			return -EAGAIN;
		}
		ret = wait_event_interruptible
		    (dev->wait_frame,
		     (!list_empty(&dev->outqueue)) ||
		     (dev->state & DEV_DISCONNECTED));
		if (ret) {
562
			mutex_unlock(&dev->fileop_lock);
563
564
565
			return ret;
		}
		if (dev->state & DEV_DISCONNECTED) {
566
			mutex_unlock(&dev->fileop_lock);
567
568
569
570
			return -ENODEV;
		}
	}

571
	f = list_entry(dev->outqueue.prev, struct em28xx_frame_t, frame);
572
573
574
575
576
577
578

	spin_lock_irqsave(&dev->queue_lock, lock_flags);
	list_for_each_entry(i, &dev->outqueue, frame)
	    i->state = F_UNUSED;
	INIT_LIST_HEAD(&dev->outqueue);
	spin_unlock_irqrestore(&dev->queue_lock, lock_flags);

579
	em28xx_queue_unusedframes(dev);
580
581
582
583
584

	if (count > f->buf.length)
		count = f->buf.length;

	if (copy_to_user(buf, f->bufmem, count)) {
585
		mutex_unlock(&dev->fileop_lock);
586
587
588
589
		return -EFAULT;
	}
	*f_pos += count;

590
	mutex_unlock(&dev->fileop_lock);
591
592
593
594
595

	return count;
}

/*
596
 * em28xx_v4l2_poll()
597
598
 * will allocate buffers when called for the first time
 */
599
static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
600
601
{
	unsigned int mask = 0;
602
	struct em28xx *dev = filp->private_data;
603

604
	if (mutex_lock_interruptible(&dev->fileop_lock))
605
606
607
		return POLLERR;

	if (dev->state & DEV_DISCONNECTED) {
608
		em28xx_videodbg("device not present\n");
609
	} else if (dev->state & DEV_MISCONFIGURED) {
610
		em28xx_videodbg("device is misconfigured; close and open it again\n");
611
612
	} else {
		if (dev->io == IO_NONE) {
613
614
615
			if (!em28xx_request_buffers
			    (dev, EM28XX_NUM_READ_FRAMES)) {
				em28xx_warn
616
617
618
619
620
621
622
623
				    ("poll() failed, not enough memory\n");
			} else {
				dev->io = IO_READ;
				dev->stream = STREAM_ON;
			}
		}

		if (dev->io == IO_READ) {
624
			em28xx_queue_unusedframes(dev);
625
626
627
628
629
			poll_wait(filp, &dev->wait_frame, wait);

			if (!list_empty(&dev->outqueue))
				mask |= POLLIN | POLLRDNORM;

630
			mutex_unlock(&dev->fileop_lock);
631
632
633
634
635

			return mask;
		}
	}

636
	mutex_unlock(&dev->fileop_lock);
637
638
639
640
	return POLLERR;
}

/*
641
 * em28xx_vm_open()
642
 */
643
static void em28xx_vm_open(struct vm_area_struct *vma)
644
{
645
	struct em28xx_frame_t *f = vma->vm_private_data;
646
647
648
649
	f->vma_use_count++;
}

/*
650
 * em28xx_vm_close()
651
 */
652
static void em28xx_vm_close(struct vm_area_struct *vma)
653
654
{
	/* NOTE: buffers are not freed here */
655
	struct em28xx_frame_t *f = vma->vm_private_data;
656
657
658
	f->vma_use_count--;
}

659
660
661
static struct vm_operations_struct em28xx_vm_ops = {
	.open = em28xx_vm_open,
	.close = em28xx_vm_close,
662
663
664
};

/*
665
 * em28xx_v4l2_mmap()
666
 */
667
static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
668
669
{
	unsigned long size = vma->vm_end - vma->vm_start,
670
671
	    start = vma->vm_start;
	void *pos;
672
	u32 i;
673

674
	struct em28xx *dev = filp->private_data;
675

676
	if (mutex_lock_interruptible(&dev->fileop_lock))
677
678
679
		return -ERESTARTSYS;

	if (dev->state & DEV_DISCONNECTED) {
680
		em28xx_videodbg("mmap: device not present\n");
681
		mutex_unlock(&dev->fileop_lock);
682
683
684
685
		return -ENODEV;
	}

	if (dev->state & DEV_MISCONFIGURED) {
686
		em28xx_videodbg ("mmap: Device is misconfigured; close and "
687
						"open it again\n");
688
		mutex_unlock(&dev->fileop_lock);
689
690
691
692
693
		return -EIO;
	}

	if (dev->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
	    size != PAGE_ALIGN(dev->frame[0].buf.length)) {
694
		mutex_unlock(&dev->fileop_lock);
695
696
697
698
699
700
701
702
		return -EINVAL;
	}

	for (i = 0; i < dev->num_frames; i++) {
		if ((dev->frame[i].buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
			break;
	}
	if (i == dev->num_frames) {
703
		em28xx_videodbg("mmap: user supplied mapping address is out of range\n");
704
		mutex_unlock(&dev->fileop_lock);
705
706
707
708
709
710
711
		return -EINVAL;
	}

	/* VM_IO is eventually going to replace PageReserved altogether */
	vma->vm_flags |= VM_IO;
	vma->vm_flags |= VM_RESERVED;	/* avoid to swap out this VMA */

712
	pos = dev->frame[i].bufmem;
713
	while (size > 0) {	/* size is page-aligned */
714
715
		if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
			em28xx_videodbg("mmap: vm_insert_page failed\n");
716
			mutex_unlock(&dev->fileop_lock);
717
718
719
720
721
722
723
			return -EAGAIN;
		}
		start += PAGE_SIZE;
		pos += PAGE_SIZE;
		size -= PAGE_SIZE;
	}

724
	vma->vm_ops = &em28xx_vm_ops;
725
726
	vma->vm_private_data = &dev->frame[i];

727
	em28xx_vm_open(vma);
728
	mutex_unlock(&dev->fileop_lock);
729
730
731
732
	return 0;
}

/*
733
 * em28xx_get_ctrl()
734
735
 * return the current saturation, brightness or contrast, mute state
 */
736
static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
737
738
739
740
741
742
743
744
{
	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		ctrl->value = dev->mute;
		return 0;
	case V4L2_CID_AUDIO_VOLUME:
		ctrl->value = dev->volume;
		return 0;
745
746
747
748
749
750
751
752
753
754
	default:
		return -EINVAL;
	}
}

/*FIXME: should be moved to saa711x */
static int saa711x_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
{
	s32 tmp;
	switch (ctrl->id) {
755
	case V4L2_CID_BRIGHTNESS:
756
		if ((tmp = em28xx_brightness_get(dev)) < 0)
757
758
759
760
			return -EIO;
		ctrl->value = (s32) ((s8) tmp);	/* FIXME: clenaer way to extend sign? */
		return 0;
	case V4L2_CID_CONTRAST:
761
		if ((ctrl->value = em28xx_contrast_get(dev)) < 0)
762
763
764
			return -EIO;
		return 0;
	case V4L2_CID_SATURATION:
765
		if ((ctrl->value = em28xx_saturation_get(dev)) < 0)
766
767
768
			return -EIO;
		return 0;
	case V4L2_CID_RED_BALANCE:
769
		if ((tmp = em28xx_v_balance_get(dev)) < 0)
770
771
772
773
			return -EIO;
		ctrl->value = (s32) ((s8) tmp);	/* FIXME: clenaer way to extend sign? */
		return 0;
	case V4L2_CID_BLUE_BALANCE:
774
		if ((tmp = em28xx_u_balance_get(dev)) < 0)
775
776
777
778
			return -EIO;
		ctrl->value = (s32) ((s8) tmp);	/* FIXME: clenaer way to extend sign? */
		return 0;
	case V4L2_CID_GAMMA:
779
		if ((ctrl->value = em28xx_gamma_get(dev)) < 0)
780
781
782
783
784
785
786
787
			return -EIO;
		return 0;
	default:
		return -EINVAL;
	}
}

/*
788
 * em28xx_set_ctrl()
789
790
 * mute or set new saturation, brightness or contrast
 */
791
static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
792
793
794
795
796
{
	switch (ctrl->id) {
	case V4L2_CID_AUDIO_MUTE:
		if (ctrl->value != dev->mute) {
			dev->mute = ctrl->value;
797
798
			em28xx_audio_usb_mute(dev, ctrl->value);
			return em28xx_audio_analog_set(dev);
799
800
801
802
		}
		return 0;
	case V4L2_CID_AUDIO_VOLUME:
		dev->volume = ctrl->value;
803
		return em28xx_audio_analog_set(dev);
804
805
806
807
808
809
810
811
812
	default:
		return -EINVAL;
	}
}

/*FIXME: should be moved to saa711x */
static int saa711x_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
{
	switch (ctrl->id) {
813
	case V4L2_CID_BRIGHTNESS:
814
		return em28xx_brightness_set(dev, ctrl->value);
815
	case V4L2_CID_CONTRAST:
816
		return em28xx_contrast_set(dev, ctrl->value);
817
	case V4L2_CID_SATURATION:
818
		return em28xx_saturation_set(dev, ctrl->value);
819
	case V4L2_CID_RED_BALANCE:
820
		return em28xx_v_balance_set(dev, ctrl->value);
821
	case V4L2_CID_BLUE_BALANCE:
822
		return em28xx_u_balance_set(dev, ctrl->value);
823
	case V4L2_CID_GAMMA:
824
		return em28xx_gamma_set(dev, ctrl->value);
825
826
827
828
829
830
	default:
		return -EINVAL;
	}
}

/*
831
 * em28xx_stream_interrupt()
832
833
 * stops streaming
 */
834
static int em28xx_stream_interrupt(struct em28xx *dev)
835
836
837
838
839
840
841
842
843
{
	int ret = 0;

	/* stop reading from the device */

	dev->stream = STREAM_INTERRUPT;
	ret = wait_event_timeout(dev->wait_stream,
				 (dev->stream == STREAM_OFF) ||
				 (dev->state & DEV_DISCONNECTED),
844
				 EM28XX_URB_TIMEOUT);
845
846
847
848
	if (dev->state & DEV_DISCONNECTED)
		return -ENODEV;
	else if (ret) {
		dev->state |= DEV_MISCONFIGURED;
849
		em28xx_videodbg("device is misconfigured; close and "
850
851
			"open /dev/video%d again\n",
				dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN);
852
853
854
855
856
857
		return ret;
	}

	return 0;
}

858
static int em28xx_set_norm(struct em28xx *dev, int width, int height)
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
{
	unsigned int hscale, vscale;
	unsigned int maxh, maxw;

	maxw = norm_maxw(dev);
	maxh = norm_maxh(dev);

	/* width must even because of the YUYV format */
	/* height must be even because of interlacing */
	height &= 0xfffe;
	width &= 0xfffe;

	if (height < 32)
		height = 32;
	if (height > maxh)
		height = maxh;
	if (width < 48)
		width = 48;
	if (width > maxw)
		width = maxw;

	if ((hscale = (((unsigned long)maxw) << 12) / width - 4096L) >= 0x4000)
		hscale = 0x3fff;
	width = (((unsigned long)maxw) << 12) / (hscale + 4096L);

	if ((vscale = (((unsigned long)maxh) << 12) / height - 4096L) >= 0x4000)
		vscale = 0x3fff;
	height = (((unsigned long)maxh) << 12) / (vscale + 4096L);

	/* set new image size */
	dev->width = width;
	dev->height = height;
	dev->frame_size = dev->width * dev->height * 2;
	dev->field_size = dev->frame_size >> 1;	/*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
	dev->bytesperline = dev->width * 2;
	dev->hscale = hscale;
	dev->vscale = vscale;

897
	em28xx_resolution_set(dev);
898
899
900
901

	return 0;
}

902
903
904
905
906
907
908
909
910
911
912
static int em28xx_get_fmt(struct em28xx *dev, struct v4l2_format *format)
{
	em28xx_videodbg("VIDIOC_G_FMT: type=%s\n",
		(format->type ==V4L2_BUF_TYPE_VIDEO_CAPTURE) ?
		"V4L2_BUF_TYPE_VIDEO_CAPTURE" :
		(format->type ==V4L2_BUF_TYPE_VBI_CAPTURE) ?
		"V4L2_BUF_TYPE_VBI_CAPTURE" :
		(format->type ==V4L2_CAP_SLICED_VBI_CAPTURE) ?
		"V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " :
		"not supported");

913
914
915
	switch (format->type) {
	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
	{
916
917
918
919
920
921
922
923
924
925
		format->fmt.pix.width = dev->width;
		format->fmt.pix.height = dev->height;
		format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
		format->fmt.pix.bytesperline = dev->bytesperline;
		format->fmt.pix.sizeimage = dev->frame_size;
		format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
		format->fmt.pix.field = dev->interlaced ? V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;	/* FIXME: TOP? NONE? BOTTOM? ALTENATE? */

		em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev->width,
			dev->height);
926
		break;
927
928
	}

929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
	{
		format->fmt.sliced.service_set=0;

		em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format);

		if (format->fmt.sliced.service_set==0)
			return -EINVAL;

		break;
	}

	default:
		return -EINVAL;
	}
	return (0);
945
946
}

947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
static int em28xx_set_fmt(struct em28xx *dev, unsigned int cmd, struct v4l2_format *format)
{
	u32 i;
	int ret = 0;
	int width = format->fmt.pix.width;
	int height = format->fmt.pix.height;
	unsigned int hscale, vscale;
	unsigned int maxh, maxw;

	maxw = norm_maxw(dev);
	maxh = norm_maxh(dev);

	em28xx_videodbg("%s: type=%s\n",
			cmd == VIDIOC_TRY_FMT ?
			"VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
			format->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
			"V4L2_BUF_TYPE_VIDEO_CAPTURE" :
			format->type == V4L2_BUF_TYPE_VBI_CAPTURE ?
			"V4L2_BUF_TYPE_VBI_CAPTURE " :
			"not supported");

	if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
		em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format);

		if (format->fmt.sliced.service_set==0)
			return -EINVAL;

		return 0;
	}


	if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return -EINVAL;

	em28xx_videodbg("%s: requested %dx%d\n",
		cmd == VIDIOC_TRY_FMT ?
		"VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
		format->fmt.pix.width, format->fmt.pix.height);

	/* FIXME: Move some code away from here */
	/* width must even because of the YUYV format */
	/* height must be even because of interlacing */
	height &= 0xfffe;
	width &= 0xfffe;

	if (height < 32)
		height = 32;
	if (height > maxh)
		height = maxh;
	if (width < 48)
		width = 48;
	if (width > maxw)
		width = maxw;

	if(dev->is_em2800){
		/* the em2800 can only scale down to 50% */
		if(height % (maxh / 2))
			height=maxh;
		if(width % (maxw / 2))
			width=maxw;
		/* according to empiatech support */
		/* the MaxPacketSize is to small to support */
		/* framesizes larger than 640x480 @ 30 fps */
		/* or 640x576 @ 25 fps. As this would cut */
		/* of a part of the image we prefer */
		/* 360x576 or 360x480 for now */
		if(width == maxw && height == maxh)
			width /= 2;
	}

1017
	if ((hscale = (((unsigned long)maxw) << 12) / width - 4096L) >= 0x4000)
1018
1019
		hscale = 0x3fff;

1020
1021
1022
	width = (((unsigned long)maxw) << 12) / (hscale + 4096L);

	if ((vscale = (((unsigned long)maxh) << 12) / height - 4096L) >= 0x4000)
1023
		vscale = 0x3fff;
1024
1025

	height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035

	format->fmt.pix.width = width;
	format->fmt.pix.height = height;
	format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
	format->fmt.pix.bytesperline = width * 2;
	format->fmt.pix.sizeimage = width * 2 * height;
	format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
	format->fmt.pix.field = V4L2_FIELD_INTERLACED;

	em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
1036
1037
1038
		cmd == VIDIOC_TRY_FMT ?
		"VIDIOC_TRY_FMT" :"VIDIOC_S_FMT",
		format->fmt.pix.width, format->fmt.pix.height, hscale, vscale);
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063

	if (cmd == VIDIOC_TRY_FMT)
		return 0;

	for (i = 0; i < dev->num_frames; i++)
		if (dev->frame[i].vma_use_count) {
			em28xx_videodbg("VIDIOC_S_FMT failed. "
				"Unmap the buffers first.\n");
			return -EINVAL;
		}

	/* stop io in case it is already in progress */
	if (dev->stream == STREAM_ON) {
		em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n");
		if ((ret = em28xx_stream_interrupt(dev)))
			return ret;
	}

	em28xx_release_buffers(dev);
	dev->io = IO_NONE;

	/* set new image size */
	dev->width = width;
	dev->height = height;
	dev->frame_size = dev->width * dev->height * 2;
1064
	dev->field_size = dev->frame_size >> 1;
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
	dev->bytesperline = dev->width * 2;
	dev->hscale = hscale;
	dev->vscale = vscale;
	em28xx_uninit_isoc(dev);
	em28xx_set_alternate(dev);
	em28xx_capture_start(dev, 1);
	em28xx_resolution_set(dev);
	em28xx_init_isoc(dev);

	return 0;
}
1076

1077
/*
1078
 * em28xx_v4l2_do_ioctl()
1079
 * This function is _not_ called directly, but from
1080
 * em28xx_v4l2_ioctl. Userspace
1081
1082
 * copying is done already, arg is a kernel pointer.
 */
1083
1084
static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
			   struct em28xx *dev, unsigned int cmd, void *arg,
1085
1086
1087
1088
1089
1090
1091
			   v4l2_kioctl driver_ioctl)
{
	int ret;

	switch (cmd) {
		/* ---------- tv norms ---------- */
	case VIDIOC_ENUMSTD:
1092
1093
1094
	{
		struct v4l2_standard *e = arg;
		unsigned int i;
1095

1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
		i = e->index;
		if (i >= TVNORMS)
			return -EINVAL;
		ret = v4l2_video_std_construct(e, tvnorms[e->index].id,
						tvnorms[e->index].name);
		e->index = i;
		if (ret < 0)
			return ret;
		return 0;
	}
1106
	case VIDIOC_G_STD:
1107
1108
	{
		v4l2_std_id *id = arg;
1109

1110
1111
1112
		*id = dev->tvnorm->id;
		return 0;
	}
1113
	case VIDIOC_S_STD:
1114
1115
1116
	{
		v4l2_std_id *id = arg;
		unsigned int i;
1117

1118
1119
1120
1121
		for (i = 0; i < TVNORMS; i++)
			if (*id == tvnorms[i].id)
				break;
		if (i == TVNORMS)
1122
			for (i = 0; i < TVNORMS; i++)
1123
				if (*id & tvnorms[i].id)
1124
					break;
1125
1126
		if (i == TVNORMS)
			return -EINVAL;
1127

1128
		mutex_lock(&dev->lock);
1129
		dev->tvnorm = &tvnorms[i];
1130

1131
		em28xx_set_norm(dev, dev->width, dev->height);
1132

1133
1134
1135
1136
		em28xx_i2c_call_clients(dev, DECODER_SET_NORM,
					&tvnorms[i].mode);
		em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
					&dev->tvnorm->id);
1137

1138
		mutex_unlock(&dev->lock);
1139

1140
1141
		return 0;
	}
1142

1143
	/* ------ input switching ---------- */
1144
	case VIDIOC_ENUMINPUT:
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
	{
		struct v4l2_input *i = arg;
		unsigned int n;
		static const char *iname[] = {
			[EM28XX_VMUX_COMPOSITE1] = "Composite1",
			[EM28XX_VMUX_COMPOSITE2] = "Composite2",
			[EM28XX_VMUX_COMPOSITE3] = "Composite3",
			[EM28XX_VMUX_COMPOSITE4] = "Composite4",
			[EM28XX_VMUX_SVIDEO] = "S-Video",
			[EM28XX_VMUX_TELEVISION] = "Television",
			[EM28XX_VMUX_CABLE] = "Cable TV",
			[EM28XX_VMUX_DVB] = "DVB",
			[EM28XX_VMUX_DEBUG] = "for debug only",
		};

		n = i->index;
		if (n >= MAX_EM28XX_INPUT)
			return -EINVAL;
		if (0 == INPUT(n)->type)
			return -EINVAL;
		memset(i, 0, sizeof(*i));
		i->index = n;
		i->type = V4L2_INPUT_TYPE_CAMERA;
		strcpy(i->name, iname[INPUT(n)->type]);
		if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
			(EM28XX_VMUX_CABLE == INPUT(n)->type))
			i->type = V4L2_INPUT_TYPE_TUNER;
		for (n = 0; n < ARRAY_SIZE(tvnorms); n++)
			i->std |= tvnorms[n].id;
		return 0;
	}
1176
	case VIDIOC_G_INPUT:
1177
1178
1179
	{
		int *i = arg;
		*i = dev->ctl_input;
1180

1181
1182
		return 0;
	}
1183
	case VIDIOC_S_INPUT:
1184
1185
	{
		int *index = arg;
1186

1187
1188
1189
1190
		if (*index >= MAX_EM28XX_INPUT)
			return -EINVAL;
		if (0 == INPUT(*index)->type)
			return -EINVAL;
1191

1192
		mutex_lock(&dev->lock);