aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/em28xx/em28xx-video.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/em28xx/em28xx-video.c')
-rw-r--r--drivers/media/video/em28xx/em28xx-video.c1613
1 files changed, 757 insertions, 856 deletions
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 5b267808a9d4..780342f7b239 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -28,6 +28,7 @@
28#include <linux/list.h> 28#include <linux/list.h>
29#include <linux/module.h> 29#include <linux/module.h>
30#include <linux/kernel.h> 30#include <linux/kernel.h>
31#include <linux/bitmap.h>
31#include <linux/usb.h> 32#include <linux/usb.h>
32#include <linux/i2c.h> 33#include <linux/i2c.h>
33#include <linux/version.h> 34#include <linux/version.h>
@@ -59,8 +60,14 @@ MODULE_LICENSE("GPL");
59static LIST_HEAD(em28xx_devlist); 60static LIST_HEAD(em28xx_devlist);
60 61
61static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET }; 62static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
63static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
64static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
62module_param_array(card, int, NULL, 0444); 65module_param_array(card, int, NULL, 0444);
66module_param_array(video_nr, int, NULL, 0444);
67module_param_array(vbi_nr, int, NULL, 0444);
63MODULE_PARM_DESC(card,"card type"); 68MODULE_PARM_DESC(card,"card type");
69MODULE_PARM_DESC(video_nr,"video device numbers");
70MODULE_PARM_DESC(vbi_nr,"vbi device numbers");
64 71
65static int tuner = -1; 72static int tuner = -1;
66module_param(tuner, int, 0444); 73module_param(tuner, int, 0444);
@@ -70,6 +77,9 @@ static unsigned int video_debug = 0;
70module_param(video_debug,int,0644); 77module_param(video_debug,int,0644);
71MODULE_PARM_DESC(video_debug,"enable debug messages [video]"); 78MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
72 79
80/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
81static unsigned long em28xx_devused;
82
73/* supported tv norms */ 83/* supported tv norms */
74static struct em28xx_tvnorm tvnorms[] = { 84static struct em28xx_tvnorm tvnorms[] = {
75 { 85 {
@@ -91,23 +101,6 @@ static struct em28xx_tvnorm tvnorms[] = {
91 } 101 }
92}; 102};
93 103
94static const unsigned char saa7114_i2c_init[] = {
95 0x00,0x00,0x01,0x08,0x02,0xc4,0x03,0x30,0x04,0x90,0x05,0x90,0x06,0xeb,0x07,0xe0,
96 0x08,0x88,0x09,0x40,0x0a,0x80,0x0b,0x44,0x0c,0x40,0x0d,0x00,0x0e,0x81,0x0f,0x2a,
97 0x10,0x06,0x11,0x00,0x12,0xc8,0x13,0x80,0x14,0x00,0x15,0x11,0x16,0x01,0x17,0x42,
98 0x18,0x40,0x19,0x80,0x40,0x00,0x41,0xff,0x42,0xff,0x43,0xff,0x44,0xff,0x45,0xff,
99 0x46,0xff,0x47,0xff,0x48,0xff,0x49,0xff,0x4a,0xff,0x4b,0xff,0x4c,0xff,0x4d,0xff,
100 0x4e,0xff,0x4f,0xff,0x50,0xff,0x51,0xff,0x52,0xff,0x53,0xff,0x54,0x5f,0x55,0xff,
101 0x56,0xff,0x57,0xff,0x58,0x00,0x59,0x47,0x5a,0x03,0x5b,0x03,0x5d,0x3e,0x5e,0x00,
102 0x80,0x1c,0x83,0x01,0x84,0xa5,0x85,0x10,0x86,0x45,0x87,0x41,0x88,0xf0,0x88,0x00,
103 0x88,0xf0,0x90,0x00,0x91,0x08,0x92,0x00,0x93,0x80,0x94,0x08,0x95,0x00,0x96,0xc0,
104 0x97,0x02,0x98,0x13,0x99,0x00,0x9a,0x38,0x9b,0x01,0x9c,0x80,0x9d,0x02,0x9e,0x06,
105 0x9f,0x01,0xa0,0x01,0xa1,0x00,0xa2,0x00,0xa4,0x80,0xa5,0x36,0xa6,0x36,0xa8,0x67,
106 0xa9,0x04,0xaa,0x00,0xac,0x33,0xad,0x02,0xae,0x00,0xb0,0xcd,0xb1,0x04,0xb2,0xcd,
107 0xb3,0x04,0xb4,0x01,0xb8,0x00,0xb9,0x00,0xba,0x00,0xbb,0x00,0xbc,0x00,0xbd,0x00,
108 0xbe,0x00,0xbf,0x00
109};
110
111#define TVNORMS ARRAY_SIZE(tvnorms) 104#define TVNORMS ARRAY_SIZE(tvnorms)
112 105
113/* supported controls */ 106/* supported controls */
@@ -134,65 +127,6 @@ static struct v4l2_queryctrl em28xx_qctrl[] = {
134 } 127 }
135}; 128};
136 129
137/* FIXME: These are specific to saa711x - should be moved to its code */
138static struct v4l2_queryctrl saa711x_qctrl[] = {
139 {
140 .id = V4L2_CID_BRIGHTNESS,
141 .type = V4L2_CTRL_TYPE_INTEGER,
142 .name = "Brightness",
143 .minimum = -128,
144 .maximum = 127,
145 .step = 1,
146 .default_value = 0,
147 .flags = 0,
148 },{
149 .id = V4L2_CID_CONTRAST,
150 .type = V4L2_CTRL_TYPE_INTEGER,
151 .name = "Contrast",
152 .minimum = 0x0,
153 .maximum = 0x1f,
154 .step = 0x1,
155 .default_value = 0x10,
156 .flags = 0,
157 },{
158 .id = V4L2_CID_SATURATION,
159 .type = V4L2_CTRL_TYPE_INTEGER,
160 .name = "Saturation",
161 .minimum = 0x0,
162 .maximum = 0x1f,
163 .step = 0x1,
164 .default_value = 0x10,
165 .flags = 0,
166 },{
167 .id = V4L2_CID_RED_BALANCE,
168 .type = V4L2_CTRL_TYPE_INTEGER,
169 .name = "Red chroma balance",
170 .minimum = -128,
171 .maximum = 127,
172 .step = 1,
173 .default_value = 0,
174 .flags = 0,
175 },{
176 .id = V4L2_CID_BLUE_BALANCE,
177 .type = V4L2_CTRL_TYPE_INTEGER,
178 .name = "Blue chroma balance",
179 .minimum = -128,
180 .maximum = 127,
181 .step = 1,
182 .default_value = 0,
183 .flags = 0,
184 },{
185 .id = V4L2_CID_GAMMA,
186 .type = V4L2_CTRL_TYPE_INTEGER,
187 .name = "Gamma",
188 .minimum = 0x0,
189 .maximum = 0x3f,
190 .step = 0x1,
191 .default_value = 0x20,
192 .flags = 0,
193 }
194};
195
196static struct usb_driver em28xx_usb_driver; 130static struct usb_driver em28xx_usb_driver;
197 131
198static DEFINE_MUTEX(em28xx_sysfs_lock); 132static DEFINE_MUTEX(em28xx_sysfs_lock);
@@ -211,6 +145,11 @@ static int em28xx_config(struct em28xx *dev)
211 em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1); 145 em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1);
212 146
213 /* enable vbi capturing */ 147 /* enable vbi capturing */
148
149/* em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */
150/* em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */
151 em28xx_write_regs_req(dev,0x00,0x11,"\x51",1);
152
214 em28xx_audio_usb_mute(dev, 1); 153 em28xx_audio_usb_mute(dev, 1);
215 dev->mute = 1; /* maybe not the right place... */ 154 dev->mute = 1; /* maybe not the right place... */
216 dev->volume = 0x1f; 155 dev->volume = 0x1f;
@@ -230,22 +169,9 @@ static int em28xx_config(struct em28xx *dev)
230static void em28xx_config_i2c(struct em28xx *dev) 169static void em28xx_config_i2c(struct em28xx *dev)
231{ 170{
232 struct v4l2_frequency f; 171 struct v4l2_frequency f;
233 struct video_decoder_init em28xx_vdi = {.data = NULL }; 172 em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, NULL);
234 173 em28xx_i2c_call_clients(dev, VIDIOC_S_INPUT, &dev->ctl_input);
235 174 em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL);
236 /* configure decoder */
237 if(dev->model == EM2820_BOARD_MSI_VOX_USB_2){
238 em28xx_vdi.data=saa7114_i2c_init;
239 em28xx_vdi.len=sizeof(saa7114_i2c_init);
240 }
241
242
243 em28xx_i2c_call_clients(dev, DECODER_INIT, &em28xx_vdi);
244 em28xx_i2c_call_clients(dev, DECODER_SET_INPUT, &dev->ctl_input);
245/* em28xx_i2c_call_clients(dev,DECODER_SET_PICTURE, &dev->vpic); */
246/* em28xx_i2c_call_clients(dev,DECODER_SET_NORM,&dev->tvnorm->id); */
247/* em28xx_i2c_call_clients(dev,DECODER_ENABLE_OUTPUT,&output); */
248/* em28xx_i2c_call_clients(dev,DECODER_DUMP, NULL); */
249 175
250 /* configure tuner */ 176 /* configure tuner */
251 f.tuner = 0; 177 f.tuner = 0;
@@ -285,8 +211,7 @@ static void video_mux(struct em28xx *dev, int index)
285 dev->ctl_input = index; 211 dev->ctl_input = index;
286 dev->ctl_ainput = INPUT(index)->amux; 212 dev->ctl_ainput = INPUT(index)->amux;
287 213
288 em28xx_i2c_call_clients(dev, DECODER_SET_INPUT, &input); 214 em28xx_i2c_call_clients(dev, VIDIOC_S_INPUT, &input);
289
290 215
291 em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,input,dev->ctl_ainput); 216 em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,input,dev->ctl_ainput);
292 217
@@ -298,11 +223,11 @@ static void video_mux(struct em28xx *dev, int index)
298 em28xx_audio_source(dev, ainput); 223 em28xx_audio_source(dev, ainput);
299 } else { 224 } else {
300 switch (dev->ctl_ainput) { 225 switch (dev->ctl_ainput) {
301 case 0: 226 case 0:
302 ainput = EM28XX_AUDIO_SRC_TUNER; 227 ainput = EM28XX_AUDIO_SRC_TUNER;
303 break; 228 break;
304 default: 229 default:
305 ainput = EM28XX_AUDIO_SRC_LINE; 230 ainput = EM28XX_AUDIO_SRC_LINE;
306 } 231 }
307 em28xx_audio_source(dev, ainput); 232 em28xx_audio_source(dev, ainput);
308 } 233 }
@@ -323,13 +248,20 @@ static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
323 h = list_entry(list, struct em28xx, devlist); 248 h = list_entry(list, struct em28xx, devlist);
324 if (h->vdev->minor == minor) { 249 if (h->vdev->minor == minor) {
325 dev = h; 250 dev = h;
251 dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
252 }
253 if (h->vbi_dev->minor == minor) {
254 dev = h;
255 dev->type = V4L2_BUF_TYPE_VBI_CAPTURE;
326 } 256 }
327 } 257 }
258 if (NULL == dev)
259 return -ENODEV;
328 260
329 filp->private_data=dev; 261 filp->private_data=dev;
330 262
331 263 em28xx_videodbg("open minor=%d type=%s users=%d\n",
332 em28xx_videodbg("users=%d\n", dev->users); 264 minor,v4l2_type_names[dev->type],dev->users);
333 265
334 if (!down_read_trylock(&em28xx_disconnect)) 266 if (!down_read_trylock(&em28xx_disconnect))
335 return -ERESTARTSYS; 267 return -ERESTARTSYS;
@@ -340,40 +272,36 @@ static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
340 return -EBUSY; 272 return -EBUSY;
341 } 273 }
342 274
343/* if(dev->vbi_dev->minor == minor){ 275 mutex_init(&dev->fileop_lock); /* to 1 == available */
344 dev->type=V4L2_BUF_TYPE_VBI_CAPTURE;
345 }*/
346 if (dev->vdev->minor == minor) {
347 dev->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
348 }
349
350 init_MUTEX(&dev->fileop_lock); /* to 1 == available */
351 spin_lock_init(&dev->queue_lock); 276 spin_lock_init(&dev->queue_lock);
352 init_waitqueue_head(&dev->wait_frame); 277 init_waitqueue_head(&dev->wait_frame);
353 init_waitqueue_head(&dev->wait_stream); 278 init_waitqueue_head(&dev->wait_stream);
354 279
355 down(&dev->lock); 280 mutex_lock(&dev->lock);
356 281
357 em28xx_set_alternate(dev); 282 if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
283 em28xx_set_alternate(dev);
358 284
359 dev->width = norm_maxw(dev); 285 dev->width = norm_maxw(dev);
360 dev->height = norm_maxh(dev); 286 dev->height = norm_maxh(dev);
361 dev->frame_size = dev->width * dev->height * 2; 287 dev->frame_size = dev->width * dev->height * 2;
362 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */ 288 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
363 dev->bytesperline = dev->width * 2; 289 dev->bytesperline = dev->width * 2;
364 dev->hscale = 0; 290 dev->hscale = 0;
365 dev->vscale = 0; 291 dev->vscale = 0;
366 292
367 em28xx_capture_start(dev, 1); 293 em28xx_capture_start(dev, 1);
368 em28xx_resolution_set(dev); 294 em28xx_resolution_set(dev);
369 295
370 /* device needs to be initialized before isoc transfer */ 296 /* device needs to be initialized before isoc transfer */
371 video_mux(dev, 0); 297 video_mux(dev, 0);
372 298
373 /* start the transfer */ 299 /* start the transfer */
374 errCode = em28xx_init_isoc(dev); 300 errCode = em28xx_init_isoc(dev);
375 if (errCode) 301 if (errCode)
376 goto err; 302 goto err;
303
304 }
377 305
378 dev->users++; 306 dev->users++;
379 filp->private_data = dev; 307 filp->private_data = dev;
@@ -386,10 +314,8 @@ static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
386 314
387 dev->state |= DEV_INITIALIZED; 315 dev->state |= DEV_INITIALIZED;
388 316
389 video_mux(dev, 0); 317err:
390 318 mutex_unlock(&dev->lock);
391 err:
392 up(&dev->lock);
393 up_read(&em28xx_disconnect); 319 up_read(&em28xx_disconnect);
394 return errCode; 320 return errCode;
395} 321}
@@ -403,14 +329,21 @@ static void em28xx_release_resources(struct em28xx *dev)
403{ 329{
404 mutex_lock(&em28xx_sysfs_lock); 330 mutex_lock(&em28xx_sysfs_lock);
405 331
406 em28xx_info("V4L2 device /dev/video%d deregistered\n", 332 /*FIXME: I2C IR should be disconnected */
407 dev->vdev->minor); 333
334 em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n",
335 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
336 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN);
408 list_del(&dev->devlist); 337 list_del(&dev->devlist);
409 video_unregister_device(dev->vdev); 338 video_unregister_device(dev->vdev);
410/* video_unregister_device(dev->vbi_dev); */ 339 video_unregister_device(dev->vbi_dev);
411 em28xx_i2c_unregister(dev); 340 em28xx_i2c_unregister(dev);
412 usb_put_dev(dev->udev); 341 usb_put_dev(dev->udev);
413 mutex_unlock(&em28xx_sysfs_lock); 342 mutex_unlock(&em28xx_sysfs_lock);
343
344
345 /* Mark device as unused */
346 em28xx_devused&=~(1<<dev->devno);
414} 347}
415 348
416/* 349/*
@@ -424,7 +357,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
424 357
425 em28xx_videodbg("users=%d\n", dev->users); 358 em28xx_videodbg("users=%d\n", dev->users);
426 359
427 down(&dev->lock); 360 mutex_lock(&dev->lock);
428 361
429 em28xx_uninit_isoc(dev); 362 em28xx_uninit_isoc(dev);
430 363
@@ -433,7 +366,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
433 /* the device is already disconnect, free the remaining resources */ 366 /* the device is already disconnect, free the remaining resources */
434 if (dev->state & DEV_DISCONNECTED) { 367 if (dev->state & DEV_DISCONNECTED) {
435 em28xx_release_resources(dev); 368 em28xx_release_resources(dev);
436 up(&dev->lock); 369 mutex_unlock(&dev->lock);
437 kfree(dev); 370 kfree(dev);
438 return 0; 371 return 0;
439 } 372 }
@@ -449,7 +382,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
449 382
450 dev->users--; 383 dev->users--;
451 wake_up_interruptible_nr(&dev->open, 1); 384 wake_up_interruptible_nr(&dev->open, 1);
452 up(&dev->lock); 385 mutex_unlock(&dev->lock);
453 return 0; 386 return 0;
454} 387}
455 388
@@ -466,32 +399,54 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
466 int ret = 0; 399 int ret = 0;
467 struct em28xx *dev = filp->private_data; 400 struct em28xx *dev = filp->private_data;
468 401
469 if (down_interruptible(&dev->fileop_lock)) 402 if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
403 em28xx_videodbg("V4l2_Buf_type_videocapture is set\n");
404 }
405 if (dev->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
406 em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n");
407 em28xx_videodbg("not supported yet! ...\n");
408 if (copy_to_user(buf, "", 1)) {
409 mutex_unlock(&dev->fileop_lock);
410 return -EFAULT;
411 }
412 return (1);
413 }
414 if (dev->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
415 em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
416 em28xx_videodbg("not supported yet! ...\n");
417 if (copy_to_user(buf, "", 1)) {
418 mutex_unlock(&dev->fileop_lock);
419 return -EFAULT;
420 }
421 return (1);
422 }
423
424 if (mutex_lock_interruptible(&dev->fileop_lock))
470 return -ERESTARTSYS; 425 return -ERESTARTSYS;
471 426
472 if (dev->state & DEV_DISCONNECTED) { 427 if (dev->state & DEV_DISCONNECTED) {
473 em28xx_videodbg("device not present\n"); 428 em28xx_videodbg("device not present\n");
474 up(&dev->fileop_lock); 429 mutex_unlock(&dev->fileop_lock);
475 return -ENODEV; 430 return -ENODEV;
476 } 431 }
477 432
478 if (dev->state & DEV_MISCONFIGURED) { 433 if (dev->state & DEV_MISCONFIGURED) {
479 em28xx_videodbg("device misconfigured; close and open it again\n"); 434 em28xx_videodbg("device misconfigured; close and open it again\n");
480 up(&dev->fileop_lock); 435 mutex_unlock(&dev->fileop_lock);
481 return -EIO; 436 return -EIO;
482 } 437 }
483 438
484 if (dev->io == IO_MMAP) { 439 if (dev->io == IO_MMAP) {
485 em28xx_videodbg ("IO method is set to mmap; close and open" 440 em28xx_videodbg ("IO method is set to mmap; close and open"
486 " the device again to choose the read method\n"); 441 " the device again to choose the read method\n");
487 up(&dev->fileop_lock); 442 mutex_unlock(&dev->fileop_lock);
488 return -EINVAL; 443 return -EINVAL;
489 } 444 }
490 445
491 if (dev->io == IO_NONE) { 446 if (dev->io == IO_NONE) {
492 if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES)) { 447 if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES)) {
493 em28xx_errdev("read failed, not enough memory\n"); 448 em28xx_errdev("read failed, not enough memory\n");
494 up(&dev->fileop_lock); 449 mutex_unlock(&dev->fileop_lock);
495 return -ENOMEM; 450 return -ENOMEM;
496 } 451 }
497 dev->io = IO_READ; 452 dev->io = IO_READ;
@@ -500,13 +455,13 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
500 } 455 }
501 456
502 if (!count) { 457 if (!count) {
503 up(&dev->fileop_lock); 458 mutex_unlock(&dev->fileop_lock);
504 return 0; 459 return 0;
505 } 460 }
506 461
507 if (list_empty(&dev->outqueue)) { 462 if (list_empty(&dev->outqueue)) {
508 if (filp->f_flags & O_NONBLOCK) { 463 if (filp->f_flags & O_NONBLOCK) {
509 up(&dev->fileop_lock); 464 mutex_unlock(&dev->fileop_lock);
510 return -EAGAIN; 465 return -EAGAIN;
511 } 466 }
512 ret = wait_event_interruptible 467 ret = wait_event_interruptible
@@ -514,11 +469,11 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
514 (!list_empty(&dev->outqueue)) || 469 (!list_empty(&dev->outqueue)) ||
515 (dev->state & DEV_DISCONNECTED)); 470 (dev->state & DEV_DISCONNECTED));
516 if (ret) { 471 if (ret) {
517 up(&dev->fileop_lock); 472 mutex_unlock(&dev->fileop_lock);
518 return ret; 473 return ret;
519 } 474 }
520 if (dev->state & DEV_DISCONNECTED) { 475 if (dev->state & DEV_DISCONNECTED) {
521 up(&dev->fileop_lock); 476 mutex_unlock(&dev->fileop_lock);
522 return -ENODEV; 477 return -ENODEV;
523 } 478 }
524 } 479 }
@@ -537,12 +492,12 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
537 count = f->buf.length; 492 count = f->buf.length;
538 493
539 if (copy_to_user(buf, f->bufmem, count)) { 494 if (copy_to_user(buf, f->bufmem, count)) {
540 up(&dev->fileop_lock); 495 mutex_unlock(&dev->fileop_lock);
541 return -EFAULT; 496 return -EFAULT;
542 } 497 }
543 *f_pos += count; 498 *f_pos += count;
544 499
545 up(&dev->fileop_lock); 500 mutex_unlock(&dev->fileop_lock);
546 501
547 return count; 502 return count;
548} 503}
@@ -556,7 +511,7 @@ static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
556 unsigned int mask = 0; 511 unsigned int mask = 0;
557 struct em28xx *dev = filp->private_data; 512 struct em28xx *dev = filp->private_data;
558 513
559 if (down_interruptible(&dev->fileop_lock)) 514 if (mutex_lock_interruptible(&dev->fileop_lock))
560 return POLLERR; 515 return POLLERR;
561 516
562 if (dev->state & DEV_DISCONNECTED) { 517 if (dev->state & DEV_DISCONNECTED) {
@@ -582,13 +537,13 @@ static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
582 if (!list_empty(&dev->outqueue)) 537 if (!list_empty(&dev->outqueue))
583 mask |= POLLIN | POLLRDNORM; 538 mask |= POLLIN | POLLRDNORM;
584 539
585 up(&dev->fileop_lock); 540 mutex_unlock(&dev->fileop_lock);
586 541
587 return mask; 542 return mask;
588 } 543 }
589 } 544 }
590 545
591 up(&dev->fileop_lock); 546 mutex_unlock(&dev->fileop_lock);
592 return POLLERR; 547 return POLLERR;
593} 548}
594 549
@@ -628,25 +583,25 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
628 583
629 struct em28xx *dev = filp->private_data; 584 struct em28xx *dev = filp->private_data;
630 585
631 if (down_interruptible(&dev->fileop_lock)) 586 if (mutex_lock_interruptible(&dev->fileop_lock))
632 return -ERESTARTSYS; 587 return -ERESTARTSYS;
633 588
634 if (dev->state & DEV_DISCONNECTED) { 589 if (dev->state & DEV_DISCONNECTED) {
635 em28xx_videodbg("mmap: device not present\n"); 590 em28xx_videodbg("mmap: device not present\n");
636 up(&dev->fileop_lock); 591 mutex_unlock(&dev->fileop_lock);
637 return -ENODEV; 592 return -ENODEV;
638 } 593 }
639 594
640 if (dev->state & DEV_MISCONFIGURED) { 595 if (dev->state & DEV_MISCONFIGURED) {
641 em28xx_videodbg ("mmap: Device is misconfigured; close and " 596 em28xx_videodbg ("mmap: Device is misconfigured; close and "
642 "open it again\n"); 597 "open it again\n");
643 up(&dev->fileop_lock); 598 mutex_unlock(&dev->fileop_lock);
644 return -EIO; 599 return -EIO;
645 } 600 }
646 601
647 if (dev->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) || 602 if (dev->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
648 size != PAGE_ALIGN(dev->frame[0].buf.length)) { 603 size != PAGE_ALIGN(dev->frame[0].buf.length)) {
649 up(&dev->fileop_lock); 604 mutex_unlock(&dev->fileop_lock);
650 return -EINVAL; 605 return -EINVAL;
651 } 606 }
652 607
@@ -656,7 +611,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
656 } 611 }
657 if (i == dev->num_frames) { 612 if (i == dev->num_frames) {
658 em28xx_videodbg("mmap: user supplied mapping address is out of range\n"); 613 em28xx_videodbg("mmap: user supplied mapping address is out of range\n");
659 up(&dev->fileop_lock); 614 mutex_unlock(&dev->fileop_lock);
660 return -EINVAL; 615 return -EINVAL;
661 } 616 }
662 617
@@ -668,7 +623,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
668 while (size > 0) { /* size is page-aligned */ 623 while (size > 0) { /* size is page-aligned */
669 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) { 624 if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
670 em28xx_videodbg("mmap: vm_insert_page failed\n"); 625 em28xx_videodbg("mmap: vm_insert_page failed\n");
671 up(&dev->fileop_lock); 626 mutex_unlock(&dev->fileop_lock);
672 return -EAGAIN; 627 return -EAGAIN;
673 } 628 }
674 start += PAGE_SIZE; 629 start += PAGE_SIZE;
@@ -680,7 +635,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
680 vma->vm_private_data = &dev->frame[i]; 635 vma->vm_private_data = &dev->frame[i];
681 636
682 em28xx_vm_open(vma); 637 em28xx_vm_open(vma);
683 up(&dev->fileop_lock); 638 mutex_unlock(&dev->fileop_lock);
684 return 0; 639 return 0;
685} 640}
686 641
@@ -702,43 +657,6 @@ static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
702 } 657 }
703} 658}
704 659
705/*FIXME: should be moved to saa711x */
706static int saa711x_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
707{
708 s32 tmp;
709 switch (ctrl->id) {
710 case V4L2_CID_BRIGHTNESS:
711 if ((tmp = em28xx_brightness_get(dev)) < 0)
712 return -EIO;
713 ctrl->value = (s32) ((s8) tmp); /* FIXME: clenaer way to extend sign? */
714 return 0;
715 case V4L2_CID_CONTRAST:
716 if ((ctrl->value = em28xx_contrast_get(dev)) < 0)
717 return -EIO;
718 return 0;
719 case V4L2_CID_SATURATION:
720 if ((ctrl->value = em28xx_saturation_get(dev)) < 0)
721 return -EIO;
722 return 0;
723 case V4L2_CID_RED_BALANCE:
724 if ((tmp = em28xx_v_balance_get(dev)) < 0)
725 return -EIO;
726 ctrl->value = (s32) ((s8) tmp); /* FIXME: clenaer way to extend sign? */
727 return 0;
728 case V4L2_CID_BLUE_BALANCE:
729 if ((tmp = em28xx_u_balance_get(dev)) < 0)
730 return -EIO;
731 ctrl->value = (s32) ((s8) tmp); /* FIXME: clenaer way to extend sign? */
732 return 0;
733 case V4L2_CID_GAMMA:
734 if ((ctrl->value = em28xx_gamma_get(dev)) < 0)
735 return -EIO;
736 return 0;
737 default:
738 return -EINVAL;
739 }
740}
741
742/* 660/*
743 * em28xx_set_ctrl() 661 * em28xx_set_ctrl()
744 * mute or set new saturation, brightness or contrast 662 * mute or set new saturation, brightness or contrast
@@ -761,27 +679,6 @@ static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
761 } 679 }
762} 680}
763 681
764/*FIXME: should be moved to saa711x */
765static int saa711x_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
766{
767 switch (ctrl->id) {
768 case V4L2_CID_BRIGHTNESS:
769 return em28xx_brightness_set(dev, ctrl->value);
770 case V4L2_CID_CONTRAST:
771 return em28xx_contrast_set(dev, ctrl->value);
772 case V4L2_CID_SATURATION:
773 return em28xx_saturation_set(dev, ctrl->value);
774 case V4L2_CID_RED_BALANCE:
775 return em28xx_v_balance_set(dev, ctrl->value);
776 case V4L2_CID_BLUE_BALANCE:
777 return em28xx_u_balance_set(dev, ctrl->value);
778 case V4L2_CID_GAMMA:
779 return em28xx_gamma_set(dev, ctrl->value);
780 default:
781 return -EINVAL;
782 }
783}
784
785/* 682/*
786 * em28xx_stream_interrupt() 683 * em28xx_stream_interrupt()
787 * stops streaming 684 * stops streaming
@@ -802,7 +699,8 @@ static int em28xx_stream_interrupt(struct em28xx *dev)
802 else if (ret) { 699 else if (ret) {
803 dev->state |= DEV_MISCONFIGURED; 700 dev->state |= DEV_MISCONFIGURED;
804 em28xx_videodbg("device is misconfigured; close and " 701 em28xx_videodbg("device is misconfigured; close and "
805 "open /dev/video%d again\n", dev->vdev->minor); 702 "open /dev/video%d again\n",
703 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN);
806 return ret; 704 return ret;
807 } 705 }
808 706
@@ -853,6 +751,181 @@ static int em28xx_set_norm(struct em28xx *dev, int width, int height)
853 return 0; 751 return 0;
854} 752}
855 753
754static int em28xx_get_fmt(struct em28xx *dev, struct v4l2_format *format)
755{
756 em28xx_videodbg("VIDIOC_G_FMT: type=%s\n",
757 (format->type ==V4L2_BUF_TYPE_VIDEO_CAPTURE) ?
758 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
759 (format->type ==V4L2_BUF_TYPE_VBI_CAPTURE) ?
760 "V4L2_BUF_TYPE_VBI_CAPTURE" :
761 (format->type ==V4L2_CAP_SLICED_VBI_CAPTURE) ?
762 "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE " :
763 "not supported");
764
765 switch (format->type) {
766 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
767 {
768 format->fmt.pix.width = dev->width;
769 format->fmt.pix.height = dev->height;
770 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
771 format->fmt.pix.bytesperline = dev->bytesperline;
772 format->fmt.pix.sizeimage = dev->frame_size;
773 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
774 format->fmt.pix.field = dev->interlaced ? V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
775
776 em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev->width,
777 dev->height);
778 break;
779 }
780
781 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
782 {
783 format->fmt.sliced.service_set=0;
784
785 em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format);
786
787 if (format->fmt.sliced.service_set==0)
788 return -EINVAL;
789
790 break;
791 }
792
793 default:
794 return -EINVAL;
795 }
796 return (0);
797}
798
799static int em28xx_set_fmt(struct em28xx *dev, unsigned int cmd, struct v4l2_format *format)
800{
801 u32 i;
802 int ret = 0;
803 int width = format->fmt.pix.width;
804 int height = format->fmt.pix.height;
805 unsigned int hscale, vscale;
806 unsigned int maxh, maxw;
807
808 maxw = norm_maxw(dev);
809 maxh = norm_maxh(dev);
810
811 em28xx_videodbg("%s: type=%s\n",
812 cmd == VIDIOC_TRY_FMT ?
813 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
814 format->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ?
815 "V4L2_BUF_TYPE_VIDEO_CAPTURE" :
816 format->type == V4L2_BUF_TYPE_VBI_CAPTURE ?
817 "V4L2_BUF_TYPE_VBI_CAPTURE " :
818 "not supported");
819
820 if (format->type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE) {
821 em28xx_i2c_call_clients(dev,VIDIOC_G_FMT,format);
822
823 if (format->fmt.sliced.service_set==0)
824 return -EINVAL;
825
826 return 0;
827 }
828
829
830 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
831 return -EINVAL;
832
833 em28xx_videodbg("%s: requested %dx%d\n",
834 cmd == VIDIOC_TRY_FMT ?
835 "VIDIOC_TRY_FMT" : "VIDIOC_S_FMT",
836 format->fmt.pix.width, format->fmt.pix.height);
837
838 /* FIXME: Move some code away from here */
839 /* width must even because of the YUYV format */
840 /* height must be even because of interlacing */
841 height &= 0xfffe;
842 width &= 0xfffe;
843
844 if (height < 32)
845 height = 32;
846 if (height > maxh)
847 height = maxh;
848 if (width < 48)
849 width = 48;
850 if (width > maxw)
851 width = maxw;
852
853 if(dev->is_em2800){
854 /* the em2800 can only scale down to 50% */
855 if(height % (maxh / 2))
856 height=maxh;
857 if(width % (maxw / 2))
858 width=maxw;
859 /* according to empiatech support */
860 /* the MaxPacketSize is to small to support */
861 /* framesizes larger than 640x480 @ 30 fps */
862 /* or 640x576 @ 25 fps. As this would cut */
863 /* of a part of the image we prefer */
864 /* 360x576 or 360x480 for now */
865 if(width == maxw && height == maxh)
866 width /= 2;
867 }
868
869 if ((hscale = (((unsigned long)maxw) << 12) / width - 4096L) >= 0x4000)
870 hscale = 0x3fff;
871
872 width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
873
874 if ((vscale = (((unsigned long)maxh) << 12) / height - 4096L) >= 0x4000)
875 vscale = 0x3fff;
876
877 height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
878
879 format->fmt.pix.width = width;
880 format->fmt.pix.height = height;
881 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
882 format->fmt.pix.bytesperline = width * 2;
883 format->fmt.pix.sizeimage = width * 2 * height;
884 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
885 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
886
887 em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
888 cmd == VIDIOC_TRY_FMT ?
889 "VIDIOC_TRY_FMT" :"VIDIOC_S_FMT",
890 format->fmt.pix.width, format->fmt.pix.height, hscale, vscale);
891
892 if (cmd == VIDIOC_TRY_FMT)
893 return 0;
894
895 for (i = 0; i < dev->num_frames; i++)
896 if (dev->frame[i].vma_use_count) {
897 em28xx_videodbg("VIDIOC_S_FMT failed. "
898 "Unmap the buffers first.\n");
899 return -EINVAL;
900 }
901
902 /* stop io in case it is already in progress */
903 if (dev->stream == STREAM_ON) {
904 em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n");
905 if ((ret = em28xx_stream_interrupt(dev)))
906 return ret;
907 }
908
909 em28xx_release_buffers(dev);
910 dev->io = IO_NONE;
911
912 /* set new image size */
913 dev->width = width;
914 dev->height = height;
915 dev->frame_size = dev->width * dev->height * 2;
916 dev->field_size = dev->frame_size >> 1;
917 dev->bytesperline = dev->width * 2;
918 dev->hscale = hscale;
919 dev->vscale = vscale;
920 em28xx_uninit_isoc(dev);
921 em28xx_set_alternate(dev);
922 em28xx_capture_start(dev, 1);
923 em28xx_resolution_set(dev);
924 em28xx_init_isoc(dev);
925
926 return 0;
927}
928
856/* 929/*
857 * em28xx_v4l2_do_ioctl() 930 * em28xx_v4l2_do_ioctl()
858 * This function is _not_ called directly, but from 931 * This function is _not_ called directly, but from
@@ -868,392 +941,325 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
868 switch (cmd) { 941 switch (cmd) {
869 /* ---------- tv norms ---------- */ 942 /* ---------- tv norms ---------- */
870 case VIDIOC_ENUMSTD: 943 case VIDIOC_ENUMSTD:
871 { 944 {
872 struct v4l2_standard *e = arg; 945 struct v4l2_standard *e = arg;
873 unsigned int i; 946 unsigned int i;
874 947
875 i = e->index; 948 i = e->index;
876 if (i >= TVNORMS) 949 if (i >= TVNORMS)
877 return -EINVAL; 950 return -EINVAL;
878 ret = v4l2_video_std_construct(e, tvnorms[e->index].id, 951 ret = v4l2_video_std_construct(e, tvnorms[e->index].id,
879 tvnorms[e->index].name); 952 tvnorms[e->index].name);
880 e->index = i; 953 e->index = i;
881 if (ret < 0) 954 if (ret < 0)
882 return ret; 955 return ret;
883 return 0; 956 return 0;
884 } 957 }
885 case VIDIOC_G_STD: 958 case VIDIOC_G_STD:
886 { 959 {
887 v4l2_std_id *id = arg; 960 v4l2_std_id *id = arg;
888 961
889 *id = dev->tvnorm->id; 962 *id = dev->tvnorm->id;
890 return 0; 963 return 0;
891 } 964 }
892 case VIDIOC_S_STD: 965 case VIDIOC_S_STD:
893 { 966 {
894 v4l2_std_id *id = arg; 967 v4l2_std_id *id = arg;
895 unsigned int i; 968 unsigned int i;
896 969
970 for (i = 0; i < TVNORMS; i++)
971 if (*id == tvnorms[i].id)
972 break;
973 if (i == TVNORMS)
897 for (i = 0; i < TVNORMS; i++) 974 for (i = 0; i < TVNORMS; i++)
898 if (*id == tvnorms[i].id) 975 if (*id & tvnorms[i].id)
899 break; 976 break;
900 if (i == TVNORMS) 977 if (i == TVNORMS)
901 for (i = 0; i < TVNORMS; i++) 978 return -EINVAL;
902 if (*id & tvnorms[i].id)
903 break;
904 if (i == TVNORMS)
905 return -EINVAL;
906
907 down(&dev->lock);
908 dev->tvnorm = &tvnorms[i];
909 979
910 em28xx_set_norm(dev, dev->width, dev->height); 980 mutex_lock(&dev->lock);
981 dev->tvnorm = &tvnorms[i];
911 982
912/* 983 em28xx_set_norm(dev, dev->width, dev->height);
913 dev->width=norm_maxw(dev);
914 dev->height=norm_maxh(dev);
915 dev->frame_size=dev->width*dev->height*2;
916 dev->field_size=dev->frame_size>>1;
917 dev->bytesperline=dev->width*2;
918 dev->hscale=0;
919 dev->vscale=0;
920 984
921 em28xx_resolution_set(dev); 985 em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
922*/ 986 &dev->tvnorm->id);
923/*
924 em28xx_uninit_isoc(dev);
925 em28xx_set_alternate(dev);
926 em28xx_capture_start(dev, 1);
927 em28xx_resolution_set(dev);
928 em28xx_init_isoc(dev);
929*/
930 em28xx_i2c_call_clients(dev, DECODER_SET_NORM,
931 &tvnorms[i].mode);
932 em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
933 &dev->tvnorm->id);
934 987
935 up(&dev->lock); 988 mutex_unlock(&dev->lock);
936 989
937 return 0; 990 return 0;
938 } 991 }
939 992
940 /* ------ input switching ---------- */ 993 /* ------ input switching ---------- */
941 case VIDIOC_ENUMINPUT: 994 case VIDIOC_ENUMINPUT:
942 { 995 {
943 struct v4l2_input *i = arg; 996 struct v4l2_input *i = arg;
944 unsigned int n; 997 unsigned int n;
945 static const char *iname[] = { 998 static const char *iname[] = {
946 [EM28XX_VMUX_COMPOSITE1] = "Composite1", 999 [EM28XX_VMUX_COMPOSITE1] = "Composite1",
947 [EM28XX_VMUX_COMPOSITE2] = "Composite2", 1000 [EM28XX_VMUX_COMPOSITE2] = "Composite2",
948 [EM28XX_VMUX_COMPOSITE3] = "Composite3", 1001 [EM28XX_VMUX_COMPOSITE3] = "Composite3",
949 [EM28XX_VMUX_COMPOSITE4] = "Composite4", 1002 [EM28XX_VMUX_COMPOSITE4] = "Composite4",
950 [EM28XX_VMUX_SVIDEO] = "S-Video", 1003 [EM28XX_VMUX_SVIDEO] = "S-Video",
951 [EM28XX_VMUX_TELEVISION] = "Television", 1004 [EM28XX_VMUX_TELEVISION] = "Television",
952 [EM28XX_VMUX_CABLE] = "Cable TV", 1005 [EM28XX_VMUX_CABLE] = "Cable TV",
953 [EM28XX_VMUX_DVB] = "DVB", 1006 [EM28XX_VMUX_DVB] = "DVB",
954 [EM28XX_VMUX_DEBUG] = "for debug only", 1007 [EM28XX_VMUX_DEBUG] = "for debug only",
955 }; 1008 };
956 1009
957 n = i->index; 1010 n = i->index;
958 if (n >= MAX_EM28XX_INPUT) 1011 if (n >= MAX_EM28XX_INPUT)
959 return -EINVAL; 1012 return -EINVAL;
960 if (0 == INPUT(n)->type) 1013 if (0 == INPUT(n)->type)
961 return -EINVAL; 1014 return -EINVAL;
962 memset(i, 0, sizeof(*i)); 1015 memset(i, 0, sizeof(*i));
963 i->index = n; 1016 i->index = n;
964 i->type = V4L2_INPUT_TYPE_CAMERA; 1017 i->type = V4L2_INPUT_TYPE_CAMERA;
965 strcpy(i->name, iname[INPUT(n)->type]); 1018 strcpy(i->name, iname[INPUT(n)->type]);
966 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) || 1019 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
967 (EM28XX_VMUX_CABLE == INPUT(n)->type)) 1020 (EM28XX_VMUX_CABLE == INPUT(n)->type))
968 i->type = V4L2_INPUT_TYPE_TUNER; 1021 i->type = V4L2_INPUT_TYPE_TUNER;
969 for (n = 0; n < ARRAY_SIZE(tvnorms); n++) 1022 for (n = 0; n < ARRAY_SIZE(tvnorms); n++)
970 i->std |= tvnorms[n].id; 1023 i->std |= tvnorms[n].id;
971 return 0; 1024 return 0;
972 } 1025 }
973
974 case VIDIOC_G_INPUT: 1026 case VIDIOC_G_INPUT:
975 { 1027 {
976 int *i = arg; 1028 int *i = arg;
977 *i = dev->ctl_input; 1029 *i = dev->ctl_input;
978
979 return 0;
980 }
981 1030
1031 return 0;
1032 }
982 case VIDIOC_S_INPUT: 1033 case VIDIOC_S_INPUT:
983 { 1034 {
984 int *index = arg; 1035 int *index = arg;
985
986 if (*index >= MAX_EM28XX_INPUT)
987 return -EINVAL;
988 if (0 == INPUT(*index)->type)
989 return -EINVAL;
990 1036
991 down(&dev->lock); 1037 if (*index >= MAX_EM28XX_INPUT)
992 video_mux(dev, *index); 1038 return -EINVAL;
993 up(&dev->lock); 1039 if (0 == INPUT(*index)->type)
1040 return -EINVAL;
994 1041
995 return 0; 1042 mutex_lock(&dev->lock);
996 } 1043 video_mux(dev, *index);
1044 mutex_unlock(&dev->lock);
997 1045
1046 return 0;
1047 }
998 case VIDIOC_G_AUDIO: 1048 case VIDIOC_G_AUDIO:
999 { 1049 {
1000 struct v4l2_audio *a = arg; 1050 struct v4l2_audio *a = arg;
1001 unsigned int index = a->index; 1051 unsigned int index = a->index;
1002 1052
1003 if (a->index > 1) 1053 if (a->index > 1)
1004 return -EINVAL; 1054 return -EINVAL;
1005 memset(a, 0, sizeof(*a)); 1055 memset(a, 0, sizeof(*a));
1006 index = dev->ctl_ainput; 1056 index = dev->ctl_ainput;
1007 1057
1008 if (index == 0) { 1058 if (index == 0) {
1009 strcpy(a->name, "Television"); 1059 strcpy(a->name, "Television");
1010 } else { 1060 } else {
1011 strcpy(a->name, "Line In"); 1061 strcpy(a->name, "Line In");
1012 }
1013 a->capability = V4L2_AUDCAP_STEREO;
1014 a->index = index;
1015 return 0;
1016 } 1062 }
1017 1063 a->capability = V4L2_AUDCAP_STEREO;
1064 a->index = index;
1065 return 0;
1066 }
1018 case VIDIOC_S_AUDIO: 1067 case VIDIOC_S_AUDIO:
1019 { 1068 {
1020 struct v4l2_audio *a = arg; 1069 struct v4l2_audio *a = arg;
1021 if (a->index != dev->ctl_ainput)
1022 return -EINVAL;
1023 1070
1024 return 0; 1071 if (a->index != dev->ctl_ainput)
1025 } 1072 return -EINVAL;
1026 1073
1027 /* --- controls ---------------------------------------------- */ 1074 return 0;
1075 }
1076
1077 /* --- controls ---------------------------------------------- */
1028 case VIDIOC_QUERYCTRL: 1078 case VIDIOC_QUERYCTRL:
1029 { 1079 {
1030 struct v4l2_queryctrl *qc = arg; 1080 struct v4l2_queryctrl *qc = arg;
1031 int i, id=qc->id; 1081 int i, id=qc->id;
1032
1033 memset(qc,0,sizeof(*qc));
1034 qc->id=id;
1035
1036 if (!dev->has_msp34xx) {
1037 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1038 if (qc->id && qc->id == em28xx_qctrl[i].id) {
1039 memcpy(qc, &(em28xx_qctrl[i]),
1040 sizeof(*qc));
1041 return 0;
1042 }
1043 }
1044 }
1045 if (dev->decoder == EM28XX_TVP5150) {
1046 em28xx_i2c_call_clients(dev,cmd,qc);
1047 if (qc->type)
1048 return 0;
1049 else
1050 return -EINVAL;
1051 }
1052 for (i = 0; i < ARRAY_SIZE(saa711x_qctrl); i++) {
1053 if (qc->id && qc->id == saa711x_qctrl[i].id) {
1054 memcpy(qc, &(saa711x_qctrl[i]),
1055 sizeof(*qc));
1056 return 0;
1057 }
1058 }
1059 1082
1060 return -EINVAL; 1083 memset(qc,0,sizeof(*qc));
1061 } 1084 qc->id=id;
1062 1085
1063 case VIDIOC_G_CTRL: 1086 if (!dev->has_msp34xx) {
1064 { 1087 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1065 struct v4l2_control *ctrl = arg; 1088 if (qc->id && qc->id == em28xx_qctrl[i].id) {
1066 int retval=-EINVAL; 1089 memcpy(qc, &(em28xx_qctrl[i]),
1067 1090 sizeof(*qc));
1068 if (!dev->has_msp34xx)
1069 retval=em28xx_get_ctrl(dev, ctrl);
1070 if (retval==-EINVAL) {
1071 if (dev->decoder == EM28XX_TVP5150) {
1072 em28xx_i2c_call_clients(dev,cmd,arg);
1073 return 0; 1091 return 0;
1074 } 1092 }
1075 1093 }
1076 return saa711x_get_ctrl(dev, ctrl);
1077 } else return retval;
1078 } 1094 }
1095 em28xx_i2c_call_clients(dev,cmd,qc);
1096 if (qc->type)
1097 return 0;
1098 else
1099 return -EINVAL;
1100 }
1101 case VIDIOC_G_CTRL:
1102 {
1103 struct v4l2_control *ctrl = arg;
1104 int retval=-EINVAL;
1079 1105
1106 if (!dev->has_msp34xx)
1107 retval=em28xx_get_ctrl(dev, ctrl);
1108 if (retval==-EINVAL) {
1109 em28xx_i2c_call_clients(dev,cmd,arg);
1110 return 0;
1111 } else return retval;
1112 }
1080 case VIDIOC_S_CTRL: 1113 case VIDIOC_S_CTRL:
1081 { 1114 {
1082 struct v4l2_control *ctrl = arg; 1115 struct v4l2_control *ctrl = arg;
1083 u8 i; 1116 u8 i;
1084 1117
1085 if (!dev->has_msp34xx){ 1118 if (!dev->has_msp34xx){
1086 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) { 1119 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1087 if (ctrl->id == em28xx_qctrl[i].id) { 1120 if (ctrl->id == em28xx_qctrl[i].id) {
1088 if (ctrl->value < 1121 if (ctrl->value <
1089 em28xx_qctrl[i].minimum 1122 em28xx_qctrl[i].minimum
1090 || ctrl->value > 1123 || ctrl->value >
1091 em28xx_qctrl[i].maximum) 1124 em28xx_qctrl[i].maximum)
1092 return -ERANGE; 1125 return -ERANGE;
1093 return em28xx_set_ctrl(dev, ctrl); 1126 return em28xx_set_ctrl(dev, ctrl);
1094 }
1095 }
1096 }
1097
1098 if (dev->decoder == EM28XX_TVP5150) {
1099 em28xx_i2c_call_clients(dev,cmd,arg);
1100 return 0;
1101 } else if (!dev->has_msp34xx) {
1102 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1103 if (ctrl->id == em28xx_qctrl[i].id) {
1104 if (ctrl->value <
1105 em28xx_qctrl[i].minimum
1106 || ctrl->value >
1107 em28xx_qctrl[i].maximum)
1108 return -ERANGE;
1109 return em28xx_set_ctrl(dev, ctrl);
1110 }
1111 }
1112 for (i = 0; i < ARRAY_SIZE(saa711x_qctrl); i++) {
1113 if (ctrl->id == saa711x_qctrl[i].id) {
1114 if (ctrl->value <
1115 saa711x_qctrl[i].minimum
1116 || ctrl->value >
1117 saa711x_qctrl[i].maximum)
1118 return -ERANGE;
1119 return saa711x_set_ctrl(dev, ctrl);
1120 }
1121 } 1127 }
1122 } 1128 }
1123
1124 return -EINVAL;
1125 } 1129 }
1126 1130
1127 /* --- tuner ioctls ------------------------------------------ */ 1131 em28xx_i2c_call_clients(dev,cmd,arg);
1132 return 0;
1133 }
1134 /* --- tuner ioctls ------------------------------------------ */
1128 case VIDIOC_G_TUNER: 1135 case VIDIOC_G_TUNER:
1129 { 1136 {
1130 struct v4l2_tuner *t = arg; 1137 struct v4l2_tuner *t = arg;
1131 int status = 0; 1138 int status = 0;
1132 1139
1133 if (0 != t->index) 1140 if (0 != t->index)
1134 return -EINVAL; 1141 return -EINVAL;
1135 1142
1136 memset(t, 0, sizeof(*t)); 1143 memset(t, 0, sizeof(*t));
1137 strcpy(t->name, "Tuner"); 1144 strcpy(t->name, "Tuner");
1138 t->type = V4L2_TUNER_ANALOG_TV; 1145 t->type = V4L2_TUNER_ANALOG_TV;
1139 t->capability = V4L2_TUNER_CAP_NORM; 1146 t->capability = V4L2_TUNER_CAP_NORM;
1140 t->rangehigh = 0xffffffffUL; /* FIXME: set correct range */ 1147 t->rangehigh = 0xffffffffUL; /* FIXME: set correct range */
1141/* t->signal = 0xffff;*/ 1148/* t->signal = 0xffff;*/
1142/* em28xx_i2c_call_clients(dev,VIDIOC_G_TUNER,t);*/ 1149/* em28xx_i2c_call_clients(dev,VIDIOC_G_TUNER,t);*/
1143 /* No way to get signal strength? */ 1150 /* No way to get signal strength? */
1144 down(&dev->lock); 1151 mutex_lock(&dev->lock);
1145 em28xx_i2c_call_clients(dev, DECODER_GET_STATUS, 1152 em28xx_i2c_call_clients(dev, DECODER_GET_STATUS,
1146 &status); 1153 &status);
1147 up(&dev->lock); 1154 mutex_unlock(&dev->lock);
1148 t->signal = 1155 t->signal =
1149 (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0; 1156 (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0;
1150 1157
1151 em28xx_videodbg("VIDIO_G_TUNER: signal=%x, afc=%x\n", t->signal, 1158 em28xx_videodbg("VIDIO_G_TUNER: signal=%x, afc=%x\n", t->signal,
1152 t->afc); 1159 t->afc);
1153 return 0; 1160 return 0;
1154 } 1161 }
1155 case VIDIOC_S_TUNER: 1162 case VIDIOC_S_TUNER:
1156 { 1163 {
1157 struct v4l2_tuner *t = arg; 1164 struct v4l2_tuner *t = arg;
1158 int status = 0; 1165 int status = 0;
1159 1166
1160 if (0 != t->index) 1167 if (0 != t->index)
1161 return -EINVAL; 1168 return -EINVAL;
1162 memset(t, 0, sizeof(*t)); 1169 memset(t, 0, sizeof(*t));
1163 strcpy(t->name, "Tuner"); 1170 strcpy(t->name, "Tuner");
1164 t->type = V4L2_TUNER_ANALOG_TV; 1171 t->type = V4L2_TUNER_ANALOG_TV;
1165 t->capability = V4L2_TUNER_CAP_NORM; 1172 t->capability = V4L2_TUNER_CAP_NORM;
1166 t->rangehigh = 0xffffffffUL; /* FIXME: set correct range */ 1173 t->rangehigh = 0xffffffffUL; /* FIXME: set correct range */
1167/* t->signal = 0xffff; */ 1174/* t->signal = 0xffff; */
1168 /* No way to get signal strength? */ 1175 /* No way to get signal strength? */
1169 down(&dev->lock); 1176 mutex_lock(&dev->lock);
1170 em28xx_i2c_call_clients(dev, DECODER_GET_STATUS, 1177 em28xx_i2c_call_clients(dev, DECODER_GET_STATUS,
1171 &status); 1178 &status);
1172 up(&dev->lock); 1179 mutex_unlock(&dev->lock);
1173 t->signal = 1180 t->signal =
1174 (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0; 1181 (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0;
1175 1182
1176 em28xx_videodbg("VIDIO_S_TUNER: signal=%x, afc=%x\n", 1183 em28xx_videodbg("VIDIO_S_TUNER: signal=%x, afc=%x\n",
1177 t->signal, t->afc); 1184 t->signal, t->afc);
1178 return 0; 1185 return 0;
1179 } 1186 }
1180 case VIDIOC_G_FREQUENCY: 1187 case VIDIOC_G_FREQUENCY:
1181 { 1188 {
1182 struct v4l2_frequency *f = arg; 1189 struct v4l2_frequency *f = arg;
1183 1190
1184 memset(f, 0, sizeof(*f)); 1191 memset(f, 0, sizeof(*f));
1185 f->type = V4L2_TUNER_ANALOG_TV; 1192 f->type = V4L2_TUNER_ANALOG_TV;
1186 f->frequency = dev->ctl_freq; 1193 f->frequency = dev->ctl_freq;
1187 1194
1188 return 0; 1195 return 0;
1189 } 1196 }
1190 case VIDIOC_S_FREQUENCY: 1197 case VIDIOC_S_FREQUENCY:
1191 { 1198 {
1192 struct v4l2_frequency *f = arg; 1199 struct v4l2_frequency *f = arg;
1193
1194 if (0 != f->tuner)
1195 return -EINVAL;
1196 1200
1197 if (V4L2_TUNER_ANALOG_TV != f->type) 1201 if (0 != f->tuner)
1198 return -EINVAL; 1202 return -EINVAL;
1199 1203
1200 down(&dev->lock); 1204 if (V4L2_TUNER_ANALOG_TV != f->type)
1201 dev->ctl_freq = f->frequency; 1205 return -EINVAL;
1202 em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
1203 up(&dev->lock);
1204 return 0;
1205 }
1206 1206
1207 mutex_lock(&dev->lock);
1208 dev->ctl_freq = f->frequency;
1209 em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
1210 mutex_unlock(&dev->lock);
1211 return 0;
1212 }
1207 case VIDIOC_CROPCAP: 1213 case VIDIOC_CROPCAP:
1208 { 1214 {
1209 struct v4l2_cropcap *cc = arg; 1215 struct v4l2_cropcap *cc = arg;
1210 1216
1211 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1217 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1212 return -EINVAL; 1218 return -EINVAL;
1213 cc->bounds.left = 0; 1219 cc->bounds.left = 0;
1214 cc->bounds.top = 0; 1220 cc->bounds.top = 0;
1215 cc->bounds.width = dev->width; 1221 cc->bounds.width = dev->width;
1216 cc->bounds.height = dev->height; 1222 cc->bounds.height = dev->height;
1217 cc->defrect = cc->bounds; 1223 cc->defrect = cc->bounds;
1218 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */ 1224 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */
1219 cc->pixelaspect.denominator = 59; 1225 cc->pixelaspect.denominator = 59;
1220 return 0; 1226 return 0;
1221 } 1227 }
1222 case VIDIOC_STREAMON: 1228 case VIDIOC_STREAMON:
1223 { 1229 {
1224 int *type = arg; 1230 int *type = arg;
1225 1231
1226 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE 1232 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1227 || dev->io != IO_MMAP) 1233 || dev->io != IO_MMAP)
1228 return -EINVAL; 1234 return -EINVAL;
1229 1235
1230 if (list_empty(&dev->inqueue)) 1236 if (list_empty(&dev->inqueue))
1231 return -EINVAL; 1237 return -EINVAL;
1232 1238
1233 dev->stream = STREAM_ON; /* FIXME: Start video capture here? */ 1239 dev->stream = STREAM_ON; /* FIXME: Start video capture here? */
1234 1240
1235 em28xx_videodbg("VIDIOC_STREAMON: starting stream\n"); 1241 em28xx_videodbg("VIDIOC_STREAMON: starting stream\n");
1236 1242
1237 return 0; 1243 return 0;
1238 } 1244 }
1239 case VIDIOC_STREAMOFF: 1245 case VIDIOC_STREAMOFF:
1240 { 1246 {
1241 int *type = arg; 1247 int *type = arg;
1242 int ret; 1248 int ret;
1243
1244 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1245 || dev->io != IO_MMAP)
1246 return -EINVAL;
1247 1249
1248 if (dev->stream == STREAM_ON) { 1250 if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1249 em28xx_videodbg ("VIDIOC_STREAMOFF: interrupting stream\n"); 1251 || dev->io != IO_MMAP)
1250 if ((ret = em28xx_stream_interrupt(dev))) 1252 return -EINVAL;
1251 return ret;
1252 }
1253 em28xx_empty_framequeues(dev);
1254 1253
1255 return 0; 1254 if (dev->stream == STREAM_ON) {
1255 em28xx_videodbg ("VIDIOC_STREAMOFF: interrupting stream\n");
1256 if ((ret = em28xx_stream_interrupt(dev)))
1257 return ret;
1256 } 1258 }
1259 em28xx_empty_framequeues(dev);
1260
1261 return 0;
1262 }
1257 default: 1263 default:
1258 return v4l_compat_translate_ioctl(inode, filp, cmd, arg, 1264 return v4l_compat_translate_ioctl(inode, filp, cmd, arg,
1259 driver_ioctl); 1265 driver_ioctl);
@@ -1283,327 +1289,170 @@ static int em28xx_video_do_ioctl(struct inode *inode, struct file *filp,
1283 /* --- capabilities ------------------------------------------ */ 1289 /* --- capabilities ------------------------------------------ */
1284 case VIDIOC_QUERYCAP: 1290 case VIDIOC_QUERYCAP:
1285 { 1291 {
1286 struct v4l2_capability *cap = arg; 1292 struct v4l2_capability *cap = arg;
1287 1293
1288 memset(cap, 0, sizeof(*cap)); 1294 memset(cap, 0, sizeof(*cap));
1289 strlcpy(cap->driver, "em28xx", sizeof(cap->driver)); 1295 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1290 strlcpy(cap->card, em28xx_boards[dev->model].name, 1296 strlcpy(cap->card, em28xx_boards[dev->model].name,
1291 sizeof(cap->card)); 1297 sizeof(cap->card));
1292 strlcpy(cap->bus_info, dev->udev->dev.bus_id, 1298 strlcpy(cap->bus_info, dev->udev->dev.bus_id,
1293 sizeof(cap->bus_info)); 1299 sizeof(cap->bus_info));
1294 cap->version = EM28XX_VERSION_CODE; 1300 cap->version = EM28XX_VERSION_CODE;
1295 cap->capabilities = 1301 cap->capabilities =
1296 V4L2_CAP_VIDEO_CAPTURE | 1302 V4L2_CAP_SLICED_VBI_CAPTURE |
1297 V4L2_CAP_AUDIO | 1303 V4L2_CAP_VIDEO_CAPTURE |
1298 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1304 V4L2_CAP_AUDIO |
1299 if (dev->has_tuner) 1305 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1300 cap->capabilities |= V4L2_CAP_TUNER; 1306 if (dev->has_tuner)
1301 return 0; 1307 cap->capabilities |= V4L2_CAP_TUNER;
1302 } 1308 return 0;
1303 1309 }
1304 /* --- capture ioctls ---------------------------------------- */ 1310 /* --- capture ioctls ---------------------------------------- */
1305 case VIDIOC_ENUM_FMT: 1311 case VIDIOC_ENUM_FMT:
1306 { 1312 {
1307 struct v4l2_fmtdesc *fmtd = arg; 1313 struct v4l2_fmtdesc *fmtd = arg;
1308
1309 if (fmtd->index != 0)
1310 return -EINVAL;
1311 memset(fmtd, 0, sizeof(*fmtd));
1312 fmtd->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1313 strcpy(fmtd->description, "Packed YUY2");
1314 fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
1315 memset(fmtd->reserved, 0, sizeof(fmtd->reserved));
1316 return 0;
1317 }
1318 1314
1315 if (fmtd->index != 0)
1316 return -EINVAL;
1317 memset(fmtd, 0, sizeof(*fmtd));
1318 fmtd->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1319 strcpy(fmtd->description, "Packed YUY2");
1320 fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
1321 memset(fmtd->reserved, 0, sizeof(fmtd->reserved));
1322 return 0;
1323 }
1319 case VIDIOC_G_FMT: 1324 case VIDIOC_G_FMT:
1320 { 1325 return em28xx_get_fmt(dev, (struct v4l2_format *) arg);
1321 struct v4l2_format *format = arg;
1322
1323 em28xx_videodbg("VIDIOC_G_FMT: type=%s\n",
1324 format->type ==
1325 V4L2_BUF_TYPE_VIDEO_CAPTURE ?
1326 "V4L2_BUF_TYPE_VIDEO_CAPTURE" : format->type ==
1327 V4L2_BUF_TYPE_VBI_CAPTURE ?
1328 "V4L2_BUF_TYPE_VBI_CAPTURE " :
1329 "not supported");
1330
1331 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1332 return -EINVAL;
1333
1334 format->fmt.pix.width = dev->width;
1335 format->fmt.pix.height = dev->height;
1336 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1337 format->fmt.pix.bytesperline = dev->bytesperline;
1338 format->fmt.pix.sizeimage = dev->frame_size;
1339 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1340 format->fmt.pix.field = dev->interlaced ? V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP; /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1341
1342 em28xx_videodbg("VIDIOC_G_FMT: %dx%d\n", dev->width,
1343 dev->height);
1344 return 0;
1345 }
1346 1326
1347 case VIDIOC_TRY_FMT: 1327 case VIDIOC_TRY_FMT:
1348 case VIDIOC_S_FMT: 1328 case VIDIOC_S_FMT:
1349 { 1329 return em28xx_set_fmt(dev, cmd, (struct v4l2_format *)arg);
1350 struct v4l2_format *format = arg;
1351 u32 i;
1352 int ret = 0;
1353 int width = format->fmt.pix.width;
1354 int height = format->fmt.pix.height;
1355 unsigned int hscale, vscale;
1356 unsigned int maxh, maxw;
1357
1358 maxw = norm_maxw(dev);
1359 maxh = norm_maxh(dev);
1360
1361/* int both_fields; */
1362
1363 em28xx_videodbg("%s: type=%s\n",
1364 cmd ==
1365 VIDIOC_TRY_FMT ? "VIDIOC_TRY_FMT" :
1366 "VIDIOC_S_FMT",
1367 format->type ==
1368 V4L2_BUF_TYPE_VIDEO_CAPTURE ?
1369 "V4L2_BUF_TYPE_VIDEO_CAPTURE" : format->type ==
1370 V4L2_BUF_TYPE_VBI_CAPTURE ?
1371 "V4L2_BUF_TYPE_VBI_CAPTURE " :
1372 "not supported");
1373
1374 if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1375 return -EINVAL;
1376
1377 em28xx_videodbg("%s: requested %dx%d\n",
1378 cmd ==
1379 VIDIOC_TRY_FMT ? "VIDIOC_TRY_FMT" :
1380 "VIDIOC_S_FMT", format->fmt.pix.width,
1381 format->fmt.pix.height);
1382
1383 /* FIXME: Move some code away from here */
1384 /* width must even because of the YUYV format */
1385 /* height must be even because of interlacing */
1386 height &= 0xfffe;
1387 width &= 0xfffe;
1388
1389 if (height < 32)
1390 height = 32;
1391 if (height > maxh)
1392 height = maxh;
1393 if (width < 48)
1394 width = 48;
1395 if (width > maxw)
1396 width = maxw;
1397
1398 if(dev->is_em2800){
1399 /* the em2800 can only scale down to 50% */
1400 if(height % (maxh / 2))
1401 height=maxh;
1402 if(width % (maxw / 2))
1403 width=maxw;
1404 /* according to empiatech support */
1405 /* the MaxPacketSize is to small to support */
1406 /* framesizes larger than 640x480 @ 30 fps */
1407 /* or 640x576 @ 25 fps. As this would cut */
1408 /* of a part of the image we prefer */
1409 /* 360x576 or 360x480 for now */
1410 if(width == maxw && height == maxh)
1411 width /= 2;
1412 }
1413
1414 if ((hscale =
1415 (((unsigned long)maxw) << 12) / width - 4096L) >=
1416 0x4000)
1417 hscale = 0x3fff;
1418 width =
1419 (((unsigned long)maxw) << 12) / (hscale + 4096L);
1420
1421 if ((vscale =
1422 (((unsigned long)maxh) << 12) / height - 4096L) >=
1423 0x4000)
1424 vscale = 0x3fff;
1425 height =
1426 (((unsigned long)maxh) << 12) / (vscale + 4096L);
1427
1428 format->fmt.pix.width = width;
1429 format->fmt.pix.height = height;
1430 format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1431 format->fmt.pix.bytesperline = width * 2;
1432 format->fmt.pix.sizeimage = width * 2 * height;
1433 format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1434 format->fmt.pix.field = V4L2_FIELD_INTERLACED;
1435
1436 em28xx_videodbg("%s: returned %dx%d (%d, %d)\n",
1437 cmd ==
1438 VIDIOC_TRY_FMT ? "VIDIOC_TRY_FMT" :
1439 "VIDIOC_S_FMT", format->fmt.pix.width,
1440 format->fmt.pix.height, hscale, vscale);
1441
1442 if (cmd == VIDIOC_TRY_FMT)
1443 return 0;
1444
1445 for (i = 0; i < dev->num_frames; i++)
1446 if (dev->frame[i].vma_use_count) {
1447 em28xx_videodbg("VIDIOC_S_FMT failed. "
1448 "Unmap the buffers first.\n");
1449 return -EINVAL;
1450 }
1451 1330
1452 /* stop io in case it is already in progress */ 1331 case VIDIOC_REQBUFS:
1453 if (dev->stream == STREAM_ON) { 1332 {
1454 em28xx_videodbg("VIDIOC_SET_FMT: interupting stream\n"); 1333 struct v4l2_requestbuffers *rb = arg;
1455 if ((ret = em28xx_stream_interrupt(dev))) 1334 u32 i;
1456 return ret; 1335 int ret;
1457 }
1458 1336
1459 em28xx_release_buffers(dev); 1337 if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1460 dev->io = IO_NONE; 1338 rb->memory != V4L2_MEMORY_MMAP)
1461 1339 return -EINVAL;
1462 /* set new image size */
1463 dev->width = width;
1464 dev->height = height;
1465 dev->frame_size = dev->width * dev->height * 2;
1466 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
1467 dev->bytesperline = dev->width * 2;
1468 dev->hscale = hscale;
1469 dev->vscale = vscale;
1470/* dev->both_fileds = both_fileds; */
1471 em28xx_uninit_isoc(dev);
1472 em28xx_set_alternate(dev);
1473 em28xx_capture_start(dev, 1);
1474 em28xx_resolution_set(dev);
1475 em28xx_init_isoc(dev);
1476 1340
1477 return 0; 1341 if (dev->io == IO_READ) {
1342 em28xx_videodbg ("method is set to read;"
1343 " close and open the device again to"
1344 " choose the mmap I/O method\n");
1345 return -EINVAL;
1478 } 1346 }
1479 1347
1480 /* --- streaming capture ------------------------------------- */ 1348 for (i = 0; i < dev->num_frames; i++)
1481 case VIDIOC_REQBUFS: 1349 if (dev->frame[i].vma_use_count) {
1482 { 1350 em28xx_videodbg ("VIDIOC_REQBUFS failed; previous buffers are still mapped\n");
1483 struct v4l2_requestbuffers *rb = arg;
1484 u32 i;
1485 int ret;
1486
1487 if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1488 rb->memory != V4L2_MEMORY_MMAP)
1489 return -EINVAL;
1490
1491 if (dev->io == IO_READ) {
1492 em28xx_videodbg ("method is set to read;"
1493 " close and open the device again to"
1494 " choose the mmap I/O method\n");
1495 return -EINVAL; 1351 return -EINVAL;
1496 } 1352 }
1497 1353
1498 for (i = 0; i < dev->num_frames; i++) 1354 if (dev->stream == STREAM_ON) {
1499 if (dev->frame[i].vma_use_count) { 1355 em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
1500 em28xx_videodbg ("VIDIOC_REQBUFS failed; previous buffers are still mapped\n"); 1356 if ((ret = em28xx_stream_interrupt(dev)))
1501 return -EINVAL; 1357 return ret;
1502 } 1358 }
1503
1504 if (dev->stream == STREAM_ON) {
1505 em28xx_videodbg("VIDIOC_REQBUFS: interrupting stream\n");
1506 if ((ret = em28xx_stream_interrupt(dev)))
1507 return ret;
1508 }
1509
1510 em28xx_empty_framequeues(dev);
1511 1359
1512 em28xx_release_buffers(dev); 1360 em28xx_empty_framequeues(dev);
1513 if (rb->count)
1514 rb->count =
1515 em28xx_request_buffers(dev, rb->count);
1516 1361
1517 dev->frame_current = NULL; 1362 em28xx_release_buffers(dev);
1363 if (rb->count)
1364 rb->count =
1365 em28xx_request_buffers(dev, rb->count);
1518 1366
1519 em28xx_videodbg ("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n", 1367 dev->frame_current = NULL;
1520 rb->count);
1521 dev->io = rb->count ? IO_MMAP : IO_NONE;
1522 return 0;
1523 }
1524 1368
1369 em28xx_videodbg ("VIDIOC_REQBUFS: setting io method to mmap: num bufs %i\n",
1370 rb->count);
1371 dev->io = rb->count ? IO_MMAP : IO_NONE;
1372 return 0;
1373 }
1525 case VIDIOC_QUERYBUF: 1374 case VIDIOC_QUERYBUF:
1526 { 1375 {
1527 struct v4l2_buffer *b = arg; 1376 struct v4l2_buffer *b = arg;
1528 1377
1529 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1378 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1530 b->index >= dev->num_frames || dev->io != IO_MMAP) 1379 b->index >= dev->num_frames || dev->io != IO_MMAP)
1531 return -EINVAL; 1380 return -EINVAL;
1532 1381
1533 memcpy(b, &dev->frame[b->index].buf, sizeof(*b)); 1382 memcpy(b, &dev->frame[b->index].buf, sizeof(*b));
1534 1383
1535 if (dev->frame[b->index].vma_use_count) { 1384 if (dev->frame[b->index].vma_use_count) {
1536 b->flags |= V4L2_BUF_FLAG_MAPPED; 1385 b->flags |= V4L2_BUF_FLAG_MAPPED;
1537 }
1538 if (dev->frame[b->index].state == F_DONE)
1539 b->flags |= V4L2_BUF_FLAG_DONE;
1540 else if (dev->frame[b->index].state != F_UNUSED)
1541 b->flags |= V4L2_BUF_FLAG_QUEUED;
1542 return 0;
1543 } 1386 }
1387 if (dev->frame[b->index].state == F_DONE)
1388 b->flags |= V4L2_BUF_FLAG_DONE;
1389 else if (dev->frame[b->index].state != F_UNUSED)
1390 b->flags |= V4L2_BUF_FLAG_QUEUED;
1391 return 0;
1392 }
1544 case VIDIOC_QBUF: 1393 case VIDIOC_QBUF:
1545 { 1394 {
1546 struct v4l2_buffer *b = arg; 1395 struct v4l2_buffer *b = arg;
1547 unsigned long lock_flags; 1396 unsigned long lock_flags;
1548 1397
1549 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1398 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1550 b->index >= dev->num_frames || dev->io != IO_MMAP) { 1399 b->index >= dev->num_frames || dev->io != IO_MMAP) {
1551 return -EINVAL; 1400 return -EINVAL;
1552 } 1401 }
1553 1402
1554 if (dev->frame[b->index].state != F_UNUSED) { 1403 if (dev->frame[b->index].state != F_UNUSED) {
1555 return -EAGAIN; 1404 return -EAGAIN;
1556 } 1405 }
1557 dev->frame[b->index].state = F_QUEUED; 1406 dev->frame[b->index].state = F_QUEUED;
1558 1407
1559 /* add frame to fifo */ 1408 /* add frame to fifo */
1560 spin_lock_irqsave(&dev->queue_lock, lock_flags); 1409 spin_lock_irqsave(&dev->queue_lock, lock_flags);
1561 list_add_tail(&dev->frame[b->index].frame, 1410 list_add_tail(&dev->frame[b->index].frame,
1562 &dev->inqueue); 1411 &dev->inqueue);
1563 spin_unlock_irqrestore(&dev->queue_lock, lock_flags); 1412 spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
1564 1413
1565 return 0; 1414 return 0;
1566 } 1415 }
1567 case VIDIOC_DQBUF: 1416 case VIDIOC_DQBUF:
1568 { 1417 {
1569 struct v4l2_buffer *b = arg; 1418 struct v4l2_buffer *b = arg;
1570 struct em28xx_frame_t *f; 1419 struct em28xx_frame_t *f;
1571 unsigned long lock_flags; 1420 unsigned long lock_flags;
1572 int ret = 0; 1421 int ret = 0;
1573 1422
1574 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE 1423 if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1575 || dev->io != IO_MMAP) 1424 || dev->io != IO_MMAP)
1576 return -EINVAL; 1425 return -EINVAL;
1577 1426
1578 if (list_empty(&dev->outqueue)) { 1427 if (list_empty(&dev->outqueue)) {
1579 if (dev->stream == STREAM_OFF) 1428 if (dev->stream == STREAM_OFF)
1580 return -EINVAL; 1429 return -EINVAL;
1581 if (filp->f_flags & O_NONBLOCK) 1430 if (filp->f_flags & O_NONBLOCK)
1582 return -EAGAIN; 1431 return -EAGAIN;
1583 ret = wait_event_interruptible 1432 ret = wait_event_interruptible
1584 (dev->wait_frame, 1433 (dev->wait_frame,
1585 (!list_empty(&dev->outqueue)) || 1434 (!list_empty(&dev->outqueue)) ||
1586 (dev->state & DEV_DISCONNECTED)); 1435 (dev->state & DEV_DISCONNECTED));
1587 if (ret) 1436 if (ret)
1588 return ret; 1437 return ret;
1589 if (dev->state & DEV_DISCONNECTED) 1438 if (dev->state & DEV_DISCONNECTED)
1590 return -ENODEV; 1439 return -ENODEV;
1591 } 1440 }
1592 1441
1593 spin_lock_irqsave(&dev->queue_lock, lock_flags); 1442 spin_lock_irqsave(&dev->queue_lock, lock_flags);
1594 f = list_entry(dev->outqueue.next, 1443 f = list_entry(dev->outqueue.next,
1595 struct em28xx_frame_t, frame); 1444 struct em28xx_frame_t, frame);
1596 list_del(dev->outqueue.next); 1445 list_del(dev->outqueue.next);
1597 spin_unlock_irqrestore(&dev->queue_lock, lock_flags); 1446 spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
1598 1447
1599 f->state = F_UNUSED; 1448 f->state = F_UNUSED;
1600 memcpy(b, &f->buf, sizeof(*b)); 1449 memcpy(b, &f->buf, sizeof(*b));
1601 1450
1602 if (f->vma_use_count) 1451 if (f->vma_use_count)
1603 b->flags |= V4L2_BUF_FLAG_MAPPED; 1452 b->flags |= V4L2_BUF_FLAG_MAPPED;
1604 1453
1605 return 0; 1454 return 0;
1606 } 1455 }
1607 default: 1456 default:
1608 return em28xx_do_ioctl(inode, filp, dev, cmd, arg, 1457 return em28xx_do_ioctl(inode, filp, dev, cmd, arg,
1609 em28xx_video_do_ioctl); 1458 em28xx_video_do_ioctl);
@@ -1621,25 +1470,25 @@ static int em28xx_v4l2_ioctl(struct inode *inode, struct file *filp,
1621 int ret = 0; 1470 int ret = 0;
1622 struct em28xx *dev = filp->private_data; 1471 struct em28xx *dev = filp->private_data;
1623 1472
1624 if (down_interruptible(&dev->fileop_lock)) 1473 if (mutex_lock_interruptible(&dev->fileop_lock))
1625 return -ERESTARTSYS; 1474 return -ERESTARTSYS;
1626 1475
1627 if (dev->state & DEV_DISCONNECTED) { 1476 if (dev->state & DEV_DISCONNECTED) {
1628 em28xx_errdev("v4l2 ioctl: device not present\n"); 1477 em28xx_errdev("v4l2 ioctl: device not present\n");
1629 up(&dev->fileop_lock); 1478 mutex_unlock(&dev->fileop_lock);
1630 return -ENODEV; 1479 return -ENODEV;
1631 } 1480 }
1632 1481
1633 if (dev->state & DEV_MISCONFIGURED) { 1482 if (dev->state & DEV_MISCONFIGURED) {
1634 em28xx_errdev 1483 em28xx_errdev
1635 ("v4l2 ioctl: device is misconfigured; close and open it again\n"); 1484 ("v4l2 ioctl: device is misconfigured; close and open it again\n");
1636 up(&dev->fileop_lock); 1485 mutex_unlock(&dev->fileop_lock);
1637 return -EIO; 1486 return -EIO;
1638 } 1487 }
1639 1488
1640 ret = video_usercopy(inode, filp, cmd, arg, em28xx_video_do_ioctl); 1489 ret = video_usercopy(inode, filp, cmd, arg, em28xx_video_do_ioctl);
1641 1490
1642 up(&dev->fileop_lock); 1491 mutex_unlock(&dev->fileop_lock);
1643 1492
1644 return ret; 1493 return ret;
1645} 1494}
@@ -1673,7 +1522,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1673 1522
1674 dev->udev = udev; 1523 dev->udev = udev;
1675 dev->model = model; 1524 dev->model = model;
1676 init_MUTEX(&dev->lock); 1525 mutex_init(&dev->lock);
1677 init_waitqueue_head(&dev->open); 1526 init_waitqueue_head(&dev->open);
1678 1527
1679 dev->em28xx_write_regs = em28xx_write_regs; 1528 dev->em28xx_write_regs = em28xx_write_regs;
@@ -1729,10 +1578,11 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1729 dev->vpic.depth = 16; 1578 dev->vpic.depth = 16;
1730 dev->vpic.palette = VIDEO_PALETTE_YUV422; 1579 dev->vpic.palette = VIDEO_PALETTE_YUV422;
1731 1580
1581 em28xx_pre_card_setup(dev);
1732#ifdef CONFIG_MODULES 1582#ifdef CONFIG_MODULES
1733 /* request some modules */ 1583 /* request some modules */
1734 if (dev->decoder == EM28XX_SAA7113 || dev->decoder == EM28XX_SAA7114) 1584 if (dev->decoder == EM28XX_SAA7113 || dev->decoder == EM28XX_SAA7114)
1735 request_module("saa711x"); 1585 request_module("saa7115");
1736 if (dev->decoder == EM28XX_TVP5150) 1586 if (dev->decoder == EM28XX_TVP5150)
1737 request_module("tvp5150"); 1587 request_module("tvp5150");
1738 if (dev->has_tuner) 1588 if (dev->has_tuner)
@@ -1744,10 +1594,11 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1744 if (errCode) { 1594 if (errCode) {
1745 em28xx_errdev("error configuring device\n"); 1595 em28xx_errdev("error configuring device\n");
1746 kfree(dev); 1596 kfree(dev);
1597 em28xx_devused&=~(1<<dev->devno);
1747 return -ENOMEM; 1598 return -ENOMEM;
1748 } 1599 }
1749 1600
1750 down(&dev->lock); 1601 mutex_lock(&dev->lock);
1751 /* register i2c bus */ 1602 /* register i2c bus */
1752 em28xx_i2c_register(dev); 1603 em28xx_i2c_register(dev);
1753 1604
@@ -1757,7 +1608,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1757 /* configure the device */ 1608 /* configure the device */
1758 em28xx_config_i2c(dev); 1609 em28xx_config_i2c(dev);
1759 1610
1760 up(&dev->lock); 1611 mutex_unlock(&dev->lock);
1761 1612
1762 errCode = em28xx_config(dev); 1613 errCode = em28xx_config(dev);
1763 1614
@@ -1770,9 +1621,30 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1770 if (NULL == dev->vdev) { 1621 if (NULL == dev->vdev) {
1771 em28xx_errdev("cannot allocate video_device.\n"); 1622 em28xx_errdev("cannot allocate video_device.\n");
1772 kfree(dev); 1623 kfree(dev);
1624 em28xx_devused&=~(1<<dev->devno);
1773 return -ENOMEM; 1625 return -ENOMEM;
1774 } 1626 }
1775 1627
1628 dev->vbi_dev = video_device_alloc();
1629 if (NULL == dev->vbi_dev) {
1630 em28xx_errdev("cannot allocate video_device.\n");
1631 kfree(dev->vdev);
1632 kfree(dev);
1633 em28xx_devused&=~(1<<dev->devno);
1634 return -ENOMEM;
1635 }
1636
1637 /* Fills VBI device info */
1638 dev->vbi_dev->type = VFL_TYPE_VBI;
1639 dev->vbi_dev->hardware = 0;
1640 dev->vbi_dev->fops = &em28xx_v4l_fops;
1641 dev->vbi_dev->minor = -1;
1642 dev->vbi_dev->dev = &dev->udev->dev;
1643 dev->vbi_dev->release = video_device_release;
1644 snprintf(dev->vbi_dev->name, sizeof(dev->vbi_dev->name), "%s#%d %s",
1645 "em28xx",dev->devno,"vbi");
1646
1647 /* Fills CAPTURE device info */
1776 dev->vdev->type = VID_TYPE_CAPTURE; 1648 dev->vdev->type = VID_TYPE_CAPTURE;
1777 if (dev->has_tuner) 1649 if (dev->has_tuner)
1778 dev->vdev->type |= VID_TYPE_TUNER; 1650 dev->vdev->type |= VID_TYPE_TUNER;
@@ -1781,21 +1653,39 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1781 dev->vdev->minor = -1; 1653 dev->vdev->minor = -1;
1782 dev->vdev->dev = &dev->udev->dev; 1654 dev->vdev->dev = &dev->udev->dev;
1783 dev->vdev->release = video_device_release; 1655 dev->vdev->release = video_device_release;
1784 snprintf(dev->vdev->name, sizeof(dev->vdev->name), "%s", 1656 snprintf(dev->vdev->name, sizeof(dev->vbi_dev->name), "%s#%d %s",
1785 "em28xx video"); 1657 "em28xx",dev->devno,"video");
1658
1786 list_add_tail(&dev->devlist,&em28xx_devlist); 1659 list_add_tail(&dev->devlist,&em28xx_devlist);
1787 1660
1788 /* register v4l2 device */ 1661 /* register v4l2 device */
1789 down(&dev->lock); 1662 mutex_lock(&dev->lock);
1790 if ((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1))) { 1663 if ((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
1664 video_nr[dev->devno]))) {
1791 em28xx_errdev("unable to register video device (error=%i).\n", 1665 em28xx_errdev("unable to register video device (error=%i).\n",
1792 retval); 1666 retval);
1793 up(&dev->lock); 1667 mutex_unlock(&dev->lock);
1794 list_del(&dev->devlist); 1668 list_del(&dev->devlist);
1795 video_device_release(dev->vdev); 1669 video_device_release(dev->vdev);
1796 kfree(dev); 1670 kfree(dev);
1671 em28xx_devused&=~(1<<dev->devno);
1797 return -ENODEV; 1672 return -ENODEV;
1798 } 1673 }
1674
1675 if (video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
1676 vbi_nr[dev->devno]) < 0) {
1677 printk("unable to register vbi device\n");
1678 mutex_unlock(&dev->lock);
1679 list_del(&dev->devlist);
1680 video_device_release(dev->vbi_dev);
1681 video_device_release(dev->vdev);
1682 kfree(dev);
1683 em28xx_devused&=~(1<<dev->devno);
1684 return -ENODEV;
1685 } else {
1686 printk("registered VBI\n");
1687 }
1688
1799 if (dev->has_msp34xx) { 1689 if (dev->has_msp34xx) {
1800 /* Send a reset to other chips via gpio */ 1690 /* Send a reset to other chips via gpio */
1801 em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1); 1691 em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1);
@@ -1806,10 +1696,11 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
1806 } 1696 }
1807 video_mux(dev, 0); 1697 video_mux(dev, 0);
1808 1698
1809 up(&dev->lock); 1699 mutex_unlock(&dev->lock);
1810 1700
1811 em28xx_info("V4L2 device registered as /dev/video%d\n", 1701 em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
1812 dev->vdev->minor); 1702 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
1703 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN);
1813 1704
1814 return 0; 1705 return 0;
1815} 1706}
@@ -1831,6 +1722,9 @@ static int em28xx_usb_probe(struct usb_interface *interface,
1831 udev = usb_get_dev(interface_to_usbdev(interface)); 1722 udev = usb_get_dev(interface_to_usbdev(interface));
1832 ifnum = interface->altsetting[0].desc.bInterfaceNumber; 1723 ifnum = interface->altsetting[0].desc.bInterfaceNumber;
1833 1724
1725 /* Check to see next free device and mark as used */
1726 nr=find_first_zero_bit(&em28xx_devused,EM28XX_MAXBOARDS);
1727 em28xx_devused|=1<<nr;
1834 1728
1835 /* Don't register audio interfaces */ 1729 /* Don't register audio interfaces */
1836 if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) { 1730 if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
@@ -1838,6 +1732,8 @@ static int em28xx_usb_probe(struct usb_interface *interface,
1838 udev->descriptor.idVendor,udev->descriptor.idProduct, 1732 udev->descriptor.idVendor,udev->descriptor.idProduct,
1839 ifnum, 1733 ifnum,
1840 interface->altsetting[0].desc.bInterfaceClass); 1734 interface->altsetting[0].desc.bInterfaceClass);
1735
1736 em28xx_devused&=~(1<<nr);
1841 return -ENODEV; 1737 return -ENODEV;
1842 } 1738 }
1843 1739
@@ -1852,18 +1748,20 @@ static int em28xx_usb_probe(struct usb_interface *interface,
1852 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 1748 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
1853 USB_ENDPOINT_XFER_ISOC) { 1749 USB_ENDPOINT_XFER_ISOC) {
1854 em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n"); 1750 em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n");
1751 em28xx_devused&=~(1<<nr);
1855 return -ENODEV; 1752 return -ENODEV;
1856 } 1753 }
1857 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) { 1754 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
1858 em28xx_err(DRIVER_NAME " probing error: endpoint is ISO OUT endpoint!\n"); 1755 em28xx_err(DRIVER_NAME " probing error: endpoint is ISO OUT endpoint!\n");
1756 em28xx_devused&=~(1<<nr);
1859 return -ENODEV; 1757 return -ENODEV;
1860 } 1758 }
1861 1759
1862 model=id->driver_info; 1760 model=id->driver_info;
1863 nr=interface->minor;
1864 1761
1865 if (nr>EM28XX_MAXBOARDS) { 1762 if (nr >= EM28XX_MAXBOARDS) {
1866 printk (DRIVER_NAME ": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS); 1763 printk (DRIVER_NAME ": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS);
1764 em28xx_devused&=~(1<<nr);
1867 return -ENOMEM; 1765 return -ENOMEM;
1868 } 1766 }
1869 1767
@@ -1871,19 +1769,24 @@ static int em28xx_usb_probe(struct usb_interface *interface,
1871 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1769 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1872 if (dev == NULL) { 1770 if (dev == NULL) {
1873 em28xx_err(DRIVER_NAME ": out of memory!\n"); 1771 em28xx_err(DRIVER_NAME ": out of memory!\n");
1772 em28xx_devused&=~(1<<nr);
1874 return -ENOMEM; 1773 return -ENOMEM;
1875 } 1774 }
1876 1775
1776 snprintf(dev->name, 29, "em28xx #%d", nr);
1777 dev->devno=nr;
1778
1877 /* compute alternate max packet sizes */ 1779 /* compute alternate max packet sizes */
1878 uif = udev->actconfig->interface[0]; 1780 uif = udev->actconfig->interface[0];
1879 1781
1880 dev->num_alt=uif->num_altsetting; 1782 dev->num_alt=uif->num_altsetting;
1881 printk(DRIVER_NAME ": Alternate settings: %i\n",dev->num_alt); 1783 em28xx_info("Alternate settings: %i\n",dev->num_alt);
1882// dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)* 1784// dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)*
1883 dev->alt_max_pkt_size = kmalloc(32* 1785 dev->alt_max_pkt_size = kmalloc(32*
1884 dev->num_alt,GFP_KERNEL); 1786 dev->num_alt,GFP_KERNEL);
1885 if (dev->alt_max_pkt_size == NULL) { 1787 if (dev->alt_max_pkt_size == NULL) {
1886 em28xx_err(DRIVER_NAME ": out of memory!\n"); 1788 em28xx_errdev("out of memory!\n");
1789 em28xx_devused&=~(1<<nr);
1887 return -ENOMEM; 1790 return -ENOMEM;
1888 } 1791 }
1889 1792
@@ -1892,27 +1795,26 @@ static int em28xx_usb_probe(struct usb_interface *interface,
1892 wMaxPacketSize); 1795 wMaxPacketSize);
1893 dev->alt_max_pkt_size[i] = 1796 dev->alt_max_pkt_size[i] =
1894 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1); 1797 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
1895 printk(DRIVER_NAME ": Alternate setting %i, max size= %i\n",i, 1798 em28xx_info("Alternate setting %i, max size= %i\n",i,
1896 dev->alt_max_pkt_size[i]); 1799 dev->alt_max_pkt_size[i]);
1897 } 1800 }
1898 1801
1899 snprintf(dev->name, 29, "em28xx #%d", nr);
1900
1901 if ((card[nr]>=0)&&(card[nr]<em28xx_bcount)) 1802 if ((card[nr]>=0)&&(card[nr]<em28xx_bcount))
1902 model=card[nr]; 1803 model=card[nr];
1903 1804
1904 if ((model==EM2800_BOARD_UNKNOWN)||(model==EM2820_BOARD_UNKNOWN)) { 1805 if ((model==EM2800_BOARD_UNKNOWN)||(model==EM2820_BOARD_UNKNOWN)) {
1905 printk( "%s: Your board has no eeprom inside it and thus can't\n" 1806 em28xx_errdev( "Your board has no eeprom inside it and thus can't\n"
1906 "%s: be autodetected. Please pass card=<n> insmod option to\n" 1807 "%s: be autodetected. Please pass card=<n> insmod option to\n"
1907 "%s: workaround that. Redirect complaints to the vendor of\n" 1808 "%s: workaround that. Redirect complaints to the vendor of\n"
1908 "%s: the TV card. Best regards,\n" 1809 "%s: the TV card. Generic type will be used."
1810 "%s: Best regards,\n"
1909 "%s: -- tux\n", 1811 "%s: -- tux\n",
1910 dev->name,dev->name,dev->name,dev->name,dev->name); 1812 dev->name,dev->name,dev->name,dev->name,dev->name);
1911 printk("%s: Here is a list of valid choices for the card=<n> insmod option:\n", 1813 em28xx_errdev("%s: Here is a list of valid choices for the card=<n> insmod option:\n",
1912 dev->name); 1814 dev->name);
1913 for (i = 0; i < em28xx_bcount; i++) { 1815 for (i = 0; i < em28xx_bcount; i++) {
1914 printk("%s: card=%d -> %s\n", 1816 em28xx_errdev(" card=%d -> %s\n", i,
1915 dev->name, i, em28xx_boards[i].name); 1817 em28xx_boards[i].name);
1916 } 1818 }
1917 } 1819 }
1918 1820
@@ -1938,15 +1840,12 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
1938 struct em28xx *dev = usb_get_intfdata(interface); 1840 struct em28xx *dev = usb_get_intfdata(interface);
1939 usb_set_intfdata(interface, NULL); 1841 usb_set_intfdata(interface, NULL);
1940 1842
1941/*FIXME: IR should be disconnected */
1942
1943 if (!dev) 1843 if (!dev)
1944 return; 1844 return;
1945 1845
1946
1947 down_write(&em28xx_disconnect); 1846 down_write(&em28xx_disconnect);
1948 1847
1949 down(&dev->lock); 1848 mutex_lock(&dev->lock);
1950 1849
1951 em28xx_info("disconnecting %s\n", dev->vdev->name); 1850 em28xx_info("disconnecting %s\n", dev->vdev->name);
1952 1851
@@ -1955,7 +1854,9 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
1955 if (dev->users) { 1854 if (dev->users) {
1956 em28xx_warn 1855 em28xx_warn
1957 ("device /dev/video%d is open! Deregistration and memory " 1856 ("device /dev/video%d is open! Deregistration and memory "
1958 "deallocation are deferred on close.\n", dev->vdev->minor); 1857 "deallocation are deferred on close.\n",
1858 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN);
1859
1959 dev->state |= DEV_MISCONFIGURED; 1860 dev->state |= DEV_MISCONFIGURED;
1960 em28xx_uninit_isoc(dev); 1861 em28xx_uninit_isoc(dev);
1961 dev->state |= DEV_DISCONNECTED; 1862 dev->state |= DEV_DISCONNECTED;
@@ -1966,7 +1867,7 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
1966 em28xx_release_resources(dev); 1867 em28xx_release_resources(dev);
1967 } 1868 }
1968 1869
1969 up(&dev->lock); 1870 mutex_unlock(&dev->lock);
1970 1871
1971 if (!dev->users) { 1872 if (!dev->users) {
1972 kfree(dev->alt_max_pkt_size); 1873 kfree(dev->alt_max_pkt_size);