aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/videobuf-core.c
diff options
context:
space:
mode:
authorMauro Carvalho Chehab <mchehab@infradead.org>2007-12-10 08:53:20 -0500
committerMauro Carvalho Chehab <mchehab@infradead.org>2008-01-25 16:03:22 -0500
commite2c77314c9444c994087c96eb370b333d57657a7 (patch)
tree498e943a85490257f19b263fe979f001a2cd93a2 /drivers/media/video/videobuf-core.c
parent543323bcf49422c76cf13755ec4a90564065bb60 (diff)
V4L/DVB (6759): CodingStyle fixes
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
Diffstat (limited to 'drivers/media/video/videobuf-core.c')
-rw-r--r--drivers/media/video/videobuf-core.c292
1 files changed, 146 insertions, 146 deletions
diff --git a/drivers/media/video/videobuf-core.c b/drivers/media/video/videobuf-core.c
index 26d1a500173..9662d1e40a0 100644
--- a/drivers/media/video/videobuf-core.c
+++ b/drivers/media/video/videobuf-core.c
@@ -22,29 +22,32 @@
22#include <media/videobuf-core.h> 22#include <media/videobuf-core.h>
23 23
24#define MAGIC_BUFFER 0x20070728 24#define MAGIC_BUFFER 0x20070728
25#define MAGIC_CHECK(is,should) if (unlikely((is) != (should))) \ 25#define MAGIC_CHECK(is, should) do { \
26 { printk(KERN_ERR "magic mismatch: %x (expected %x)\n",is,should); BUG(); } 26 if (unlikely((is) != (should))) { \
27 printk(KERN_ERR "magic mismatch: %x (expected %x)\n", is, should); \
28 BUG(); } } while (0)
27 29
28static int debug = 0; 30static int debug;
29module_param(debug, int, 0644); 31module_param(debug, int, 0644);
30 32
31MODULE_DESCRIPTION("helper module to manage video4linux buffers"); 33MODULE_DESCRIPTION("helper module to manage video4linux buffers");
32MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); 34MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
33MODULE_LICENSE("GPL"); 35MODULE_LICENSE("GPL");
34 36
35#define dprintk(level, fmt, arg...) if (debug >= level) \ 37#define dprintk(level, fmt, arg...) do { \
36 printk(KERN_DEBUG "vbuf: " fmt , ## arg) 38 if (debug >= level) \
39 printk(KERN_DEBUG "vbuf: " fmt , ## arg); } while (0)
37 40
38/* --------------------------------------------------------------------- */ 41/* --------------------------------------------------------------------- */
39 42
40#define CALL(q, f, arg...) \ 43#define CALL(q, f, arg...) \
41 ( (q->int_ops->f)? q->int_ops->f(arg) : 0) 44 ((q->int_ops->f) ? q->int_ops->f(arg) : 0)
42 45
43void* videobuf_alloc(struct videobuf_queue* q) 46void *videobuf_alloc(struct videobuf_queue *q)
44{ 47{
45 struct videobuf_buffer *vb; 48 struct videobuf_buffer *vb;
46 49
47 BUG_ON (q->msize<sizeof(*vb)); 50 BUG_ON(q->msize < sizeof(*vb));
48 51
49 if (!q->int_ops || !q->int_ops->alloc) { 52 if (!q->int_ops || !q->int_ops->alloc) {
50 printk(KERN_ERR "No specific ops defined!\n"); 53 printk(KERN_ERR "No specific ops defined!\n");
@@ -66,7 +69,7 @@ int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr)
66 int retval = 0; 69 int retval = 0;
67 DECLARE_WAITQUEUE(wait, current); 70 DECLARE_WAITQUEUE(wait, current);
68 71
69 MAGIC_CHECK(vb->magic,MAGIC_BUFFER); 72 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
70 add_wait_queue(&vb->done, &wait); 73 add_wait_queue(&vb->done, &wait);
71 while (vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) { 74 while (vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) {
72 if (non_blocking) { 75 if (non_blocking) {
@@ -75,11 +78,12 @@ int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr)
75 } 78 }
76 set_current_state(intr ? TASK_INTERRUPTIBLE 79 set_current_state(intr ? TASK_INTERRUPTIBLE
77 : TASK_UNINTERRUPTIBLE); 80 : TASK_UNINTERRUPTIBLE);
78 if (vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) 81 if (vb->state == VIDEOBUF_ACTIVE ||
82 vb->state == VIDEOBUF_QUEUED)
79 schedule(); 83 schedule();
80 set_current_state(TASK_RUNNING); 84 set_current_state(TASK_RUNNING);
81 if (intr && signal_pending(current)) { 85 if (intr && signal_pending(current)) {
82 dprintk(1,"buffer waiton: -EINTR\n"); 86 dprintk(1, "buffer waiton: -EINTR\n");
83 retval = -EINTR; 87 retval = -EINTR;
84 break; 88 break;
85 } 89 }
@@ -88,27 +92,27 @@ int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr)
88 return retval; 92 return retval;
89} 93}
90 94
91int videobuf_iolock(struct videobuf_queue* q, struct videobuf_buffer *vb, 95int videobuf_iolock(struct videobuf_queue *q, struct videobuf_buffer *vb,
92 struct v4l2_framebuffer *fbuf) 96 struct v4l2_framebuffer *fbuf)
93{ 97{
94 MAGIC_CHECK(vb->magic,MAGIC_BUFFER); 98 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
95 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 99 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
96 100
97 /* FIXME: This is required to avoid OOPS on some cases, since mmap_mapper() 101 /* FIXME: This is required to avoid OOPS on some cases,
98 method should be called before _iolock. 102 since mmap_mapper() method should be called before _iolock.
99 On some cases, the mmap_mapper() is called only after scheduling. 103 On some cases, the mmap_mapper() is called only after scheduling.
100 104
101 However, this way is just too dirty! Better to wait for some event. 105 However, this way is just too dirty! Better to wait for some event.
102 */ 106 */
103 schedule_timeout(HZ); 107 schedule_timeout(HZ);
104 108
105 return CALL(q,iolock,q,vb,fbuf); 109 return CALL(q, iolock, q, vb, fbuf);
106} 110}
107 111
108/* --------------------------------------------------------------------- */ 112/* --------------------------------------------------------------------- */
109 113
110 114
111void videobuf_queue_core_init(struct videobuf_queue* q, 115void videobuf_queue_core_init(struct videobuf_queue *q,
112 struct videobuf_queue_ops *ops, 116 struct videobuf_queue_ops *ops,
113 void *dev, 117 void *dev,
114 spinlock_t *irqlock, 118 spinlock_t *irqlock,
@@ -118,7 +122,7 @@ void videobuf_queue_core_init(struct videobuf_queue* q,
118 void *priv, 122 void *priv,
119 struct videobuf_qtype_ops *int_ops) 123 struct videobuf_qtype_ops *int_ops)
120{ 124{
121 memset(q,0,sizeof(*q)); 125 memset(q, 0, sizeof(*q));
122 q->irqlock = irqlock; 126 q->irqlock = irqlock;
123 q->dev = dev; 127 q->dev = dev;
124 q->type = type; 128 q->type = type;
@@ -129,13 +133,13 @@ void videobuf_queue_core_init(struct videobuf_queue* q,
129 q->int_ops = int_ops; 133 q->int_ops = int_ops;
130 134
131 /* All buffer operations are mandatory */ 135 /* All buffer operations are mandatory */
132 BUG_ON (!q->ops->buf_setup); 136 BUG_ON(!q->ops->buf_setup);
133 BUG_ON (!q->ops->buf_prepare); 137 BUG_ON(!q->ops->buf_prepare);
134 BUG_ON (!q->ops->buf_queue); 138 BUG_ON(!q->ops->buf_queue);
135 BUG_ON (!q->ops->buf_release); 139 BUG_ON(!q->ops->buf_release);
136 140
137 /* Having implementations for abstract methods are mandatory */ 141 /* Having implementations for abstract methods are mandatory */
138 BUG_ON (!q->int_ops); 142 BUG_ON(!q->int_ops);
139 143
140 mutex_init(&q->lock); 144 mutex_init(&q->lock);
141 INIT_LIST_HEAD(&q->stream); 145 INIT_LIST_HEAD(&q->stream);
@@ -146,33 +150,33 @@ int videobuf_queue_is_busy(struct videobuf_queue *q)
146{ 150{
147 int i; 151 int i;
148 152
149 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 153 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
150 154
151 if (q->streaming) { 155 if (q->streaming) {
152 dprintk(1,"busy: streaming active\n"); 156 dprintk(1, "busy: streaming active\n");
153 return 1; 157 return 1;
154 } 158 }
155 if (q->reading) { 159 if (q->reading) {
156 dprintk(1,"busy: pending read #1\n"); 160 dprintk(1, "busy: pending read #1\n");
157 return 1; 161 return 1;
158 } 162 }
159 if (q->read_buf) { 163 if (q->read_buf) {
160 dprintk(1,"busy: pending read #2\n"); 164 dprintk(1, "busy: pending read #2\n");
161 return 1; 165 return 1;
162 } 166 }
163 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 167 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
164 if (NULL == q->bufs[i]) 168 if (NULL == q->bufs[i])
165 continue; 169 continue;
166 if (q->bufs[i]->map) { 170 if (q->bufs[i]->map) {
167 dprintk(1,"busy: buffer #%d mapped\n",i); 171 dprintk(1, "busy: buffer #%d mapped\n", i);
168 return 1; 172 return 1;
169 } 173 }
170 if (q->bufs[i]->state == VIDEOBUF_QUEUED) { 174 if (q->bufs[i]->state == VIDEOBUF_QUEUED) {
171 dprintk(1,"busy: buffer #%d queued\n",i); 175 dprintk(1, "busy: buffer #%d queued\n", i);
172 return 1; 176 return 1;
173 } 177 }
174 if (q->bufs[i]->state == VIDEOBUF_ACTIVE) { 178 if (q->bufs[i]->state == VIDEOBUF_ACTIVE) {
175 dprintk(1,"busy: buffer #%d avtive\n",i); 179 dprintk(1, "busy: buffer #%d avtive\n", i);
176 return 1; 180 return 1;
177 } 181 }
178 } 182 }
@@ -182,12 +186,12 @@ int videobuf_queue_is_busy(struct videobuf_queue *q)
182/* Locking: Caller holds q->lock */ 186/* Locking: Caller holds q->lock */
183void videobuf_queue_cancel(struct videobuf_queue *q) 187void videobuf_queue_cancel(struct videobuf_queue *q)
184{ 188{
185 unsigned long flags=0; 189 unsigned long flags = 0;
186 int i; 190 int i;
187 191
188 /* remove queued buffers from list */ 192 /* remove queued buffers from list */
189 if (q->irqlock) 193 if (q->irqlock)
190 spin_lock_irqsave(q->irqlock,flags); 194 spin_lock_irqsave(q->irqlock, flags);
191 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 195 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
192 if (NULL == q->bufs[i]) 196 if (NULL == q->bufs[i])
193 continue; 197 continue;
@@ -197,13 +201,13 @@ void videobuf_queue_cancel(struct videobuf_queue *q)
197 } 201 }
198 } 202 }
199 if (q->irqlock) 203 if (q->irqlock)
200 spin_unlock_irqrestore(q->irqlock,flags); 204 spin_unlock_irqrestore(q->irqlock, flags);
201 205
202 /* free all buffers + clear queue */ 206 /* free all buffers + clear queue */
203 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 207 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
204 if (NULL == q->bufs[i]) 208 if (NULL == q->bufs[i])
205 continue; 209 continue;
206 q->ops->buf_release(q,q->bufs[i]); 210 q->ops->buf_release(q, q->bufs[i]);
207 } 211 }
208 INIT_LIST_HEAD(&q->stream); 212 INIT_LIST_HEAD(&q->stream);
209} 213}
@@ -233,8 +237,8 @@ enum v4l2_field videobuf_next_field(struct videobuf_queue *q)
233static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b, 237static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b,
234 struct videobuf_buffer *vb, enum v4l2_buf_type type) 238 struct videobuf_buffer *vb, enum v4l2_buf_type type)
235{ 239{
236 MAGIC_CHECK(vb->magic,MAGIC_BUFFER); 240 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
237 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 241 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
238 242
239 b->index = vb->i; 243 b->index = vb->i;
240 b->type = type; 244 b->type = type;
@@ -294,16 +298,16 @@ static int __videobuf_mmap_free(struct videobuf_queue *q)
294 if (!q) 298 if (!q)
295 return 0; 299 return 0;
296 300
297 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 301 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
298 302
299 rc = CALL(q,mmap_free,q); 303 rc = CALL(q, mmap_free, q);
300 if (rc<0) 304 if (rc < 0)
301 return rc; 305 return rc;
302 306
303 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 307 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
304 if (NULL == q->bufs[i]) 308 if (NULL == q->bufs[i])
305 continue; 309 continue;
306 q->ops->buf_release(q,q->bufs[i]); 310 q->ops->buf_release(q, q->bufs[i]);
307 kfree(q->bufs[i]); 311 kfree(q->bufs[i]);
308 q->bufs[i] = NULL; 312 q->bufs[i] = NULL;
309 } 313 }
@@ -328,7 +332,7 @@ static int __videobuf_mmap_setup(struct videobuf_queue *q,
328 unsigned int i; 332 unsigned int i;
329 int err; 333 int err;
330 334
331 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 335 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
332 336
333 err = __videobuf_mmap_free(q); 337 err = __videobuf_mmap_free(q);
334 if (0 != err) 338 if (0 != err)
@@ -359,7 +363,7 @@ static int __videobuf_mmap_setup(struct videobuf_queue *q,
359 if (!i) 363 if (!i)
360 return -ENOMEM; 364 return -ENOMEM;
361 365
362 dprintk(1,"mmap setup: %d buffers, %d bytes each\n", 366 dprintk(1, "mmap setup: %d buffers, %d bytes each\n",
363 i, bsize); 367 i, bsize);
364 368
365 return i; 369 return i;
@@ -379,35 +383,35 @@ int videobuf_mmap_setup(struct videobuf_queue *q,
379int videobuf_reqbufs(struct videobuf_queue *q, 383int videobuf_reqbufs(struct videobuf_queue *q,
380 struct v4l2_requestbuffers *req) 384 struct v4l2_requestbuffers *req)
381{ 385{
382 unsigned int size,count; 386 unsigned int size, count;
383 int retval; 387 int retval;
384 388
385 if (req->count < 1) { 389 if (req->count < 1) {
386 dprintk(1,"reqbufs: count invalid (%d)\n",req->count); 390 dprintk(1, "reqbufs: count invalid (%d)\n", req->count);
387 return -EINVAL; 391 return -EINVAL;
388 } 392 }
389 393
390 if (req->memory != V4L2_MEMORY_MMAP && 394 if (req->memory != V4L2_MEMORY_MMAP &&
391 req->memory != V4L2_MEMORY_USERPTR && 395 req->memory != V4L2_MEMORY_USERPTR &&
392 req->memory != V4L2_MEMORY_OVERLAY) { 396 req->memory != V4L2_MEMORY_OVERLAY) {
393 dprintk(1,"reqbufs: memory type invalid\n"); 397 dprintk(1, "reqbufs: memory type invalid\n");
394 return -EINVAL; 398 return -EINVAL;
395 } 399 }
396 400
397 mutex_lock(&q->lock); 401 mutex_lock(&q->lock);
398 if (req->type != q->type) { 402 if (req->type != q->type) {
399 dprintk(1,"reqbufs: queue type invalid\n"); 403 dprintk(1, "reqbufs: queue type invalid\n");
400 retval = -EINVAL; 404 retval = -EINVAL;
401 goto done; 405 goto done;
402 } 406 }
403 407
404 if (q->streaming) { 408 if (q->streaming) {
405 dprintk(1,"reqbufs: streaming already exists\n"); 409 dprintk(1, "reqbufs: streaming already exists\n");
406 retval = -EBUSY; 410 retval = -EBUSY;
407 goto done; 411 goto done;
408 } 412 }
409 if (!list_empty(&q->stream)) { 413 if (!list_empty(&q->stream)) {
410 dprintk(1,"reqbufs: stream running\n"); 414 dprintk(1, "reqbufs: stream running\n");
411 retval = -EBUSY; 415 retval = -EBUSY;
412 goto done; 416 goto done;
413 } 417 }
@@ -416,14 +420,14 @@ int videobuf_reqbufs(struct videobuf_queue *q,
416 if (count > VIDEO_MAX_FRAME) 420 if (count > VIDEO_MAX_FRAME)
417 count = VIDEO_MAX_FRAME; 421 count = VIDEO_MAX_FRAME;
418 size = 0; 422 size = 0;
419 q->ops->buf_setup(q,&count,&size); 423 q->ops->buf_setup(q, &count, &size);
420 size = PAGE_ALIGN(size); 424 size = PAGE_ALIGN(size);
421 dprintk(1,"reqbufs: bufs=%d, size=0x%x [%d pages total]\n", 425 dprintk(1, "reqbufs: bufs=%d, size=0x%x [%d pages total]\n",
422 count, size, (count*size)>>PAGE_SHIFT); 426 count, size, (count*size)>>PAGE_SHIFT);
423 427
424 retval = __videobuf_mmap_setup(q,count,size,req->memory); 428 retval = __videobuf_mmap_setup(q, count, size, req->memory);
425 if (retval < 0) { 429 if (retval < 0) {
426 dprintk(1,"reqbufs: mmap setup returned %d\n",retval); 430 dprintk(1, "reqbufs: mmap setup returned %d\n", retval);
427 goto done; 431 goto done;
428 } 432 }
429 433
@@ -440,19 +444,19 @@ int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b)
440 444
441 mutex_lock(&q->lock); 445 mutex_lock(&q->lock);
442 if (unlikely(b->type != q->type)) { 446 if (unlikely(b->type != q->type)) {
443 dprintk(1,"querybuf: Wrong type.\n"); 447 dprintk(1, "querybuf: Wrong type.\n");
444 goto done; 448 goto done;
445 } 449 }
446 if (unlikely(b->index < 0 || b->index >= VIDEO_MAX_FRAME)) { 450 if (unlikely(b->index < 0 || b->index >= VIDEO_MAX_FRAME)) {
447 dprintk(1,"querybuf: index out of range.\n"); 451 dprintk(1, "querybuf: index out of range.\n");
448 goto done; 452 goto done;
449 } 453 }
450 if (unlikely(NULL == q->bufs[b->index])) { 454 if (unlikely(NULL == q->bufs[b->index])) {
451 dprintk(1,"querybuf: buffer is null.\n"); 455 dprintk(1, "querybuf: buffer is null.\n");
452 goto done; 456 goto done;
453 } 457 }
454 458
455 videobuf_status(q,b,q->bufs[b->index],q->type); 459 videobuf_status(q, b, q->bufs[b->index], q->type);
456 460
457 ret = 0; 461 ret = 0;
458done: 462done:
@@ -465,10 +469,10 @@ int videobuf_qbuf(struct videobuf_queue *q,
465{ 469{
466 struct videobuf_buffer *buf; 470 struct videobuf_buffer *buf;
467 enum v4l2_field field; 471 enum v4l2_field field;
468 unsigned long flags=0; 472 unsigned long flags = 0;
469 int retval; 473 int retval;
470 474
471 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 475 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
472 476
473 if (b->memory == V4L2_MEMORY_MMAP) 477 if (b->memory == V4L2_MEMORY_MMAP)
474 down_read(&current->mm->mmap_sem); 478 down_read(&current->mm->mmap_sem);
@@ -476,36 +480,36 @@ int videobuf_qbuf(struct videobuf_queue *q,
476 mutex_lock(&q->lock); 480 mutex_lock(&q->lock);
477 retval = -EBUSY; 481 retval = -EBUSY;
478 if (q->reading) { 482 if (q->reading) {
479 dprintk(1,"qbuf: Reading running...\n"); 483 dprintk(1, "qbuf: Reading running...\n");
480 goto done; 484 goto done;
481 } 485 }
482 retval = -EINVAL; 486 retval = -EINVAL;
483 if (b->type != q->type) { 487 if (b->type != q->type) {
484 dprintk(1,"qbuf: Wrong type.\n"); 488 dprintk(1, "qbuf: Wrong type.\n");
485 goto done; 489 goto done;
486 } 490 }
487 if (b->index < 0 || b->index >= VIDEO_MAX_FRAME) { 491 if (b->index < 0 || b->index >= VIDEO_MAX_FRAME) {
488 dprintk(1,"qbuf: index out of range.\n"); 492 dprintk(1, "qbuf: index out of range.\n");
489 goto done; 493 goto done;
490 } 494 }
491 buf = q->bufs[b->index]; 495 buf = q->bufs[b->index];
492 if (NULL == buf) { 496 if (NULL == buf) {
493 dprintk(1,"qbuf: buffer is null.\n"); 497 dprintk(1, "qbuf: buffer is null.\n");
494 goto done; 498 goto done;
495 } 499 }
496 MAGIC_CHECK(buf->magic,MAGIC_BUFFER); 500 MAGIC_CHECK(buf->magic, MAGIC_BUFFER);
497 if (buf->memory != b->memory) { 501 if (buf->memory != b->memory) {
498 dprintk(1,"qbuf: memory type is wrong.\n"); 502 dprintk(1, "qbuf: memory type is wrong.\n");
499 goto done; 503 goto done;
500 } 504 }
501 if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) { 505 if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) {
502 dprintk(1,"qbuf: buffer is already queued or active.\n"); 506 dprintk(1, "qbuf: buffer is already queued or active.\n");
503 goto done; 507 goto done;
504 } 508 }
505 509
506 if (b->flags & V4L2_BUF_FLAG_INPUT) { 510 if (b->flags & V4L2_BUF_FLAG_INPUT) {
507 if (b->input >= q->inputs) { 511 if (b->input >= q->inputs) {
508 dprintk(1,"qbuf: wrong input.\n"); 512 dprintk(1, "qbuf: wrong input.\n");
509 goto done; 513 goto done;
510 } 514 }
511 buf->input = b->input; 515 buf->input = b->input;
@@ -516,44 +520,46 @@ int videobuf_qbuf(struct videobuf_queue *q,
516 switch (b->memory) { 520 switch (b->memory) {
517 case V4L2_MEMORY_MMAP: 521 case V4L2_MEMORY_MMAP:
518 if (0 == buf->baddr) { 522 if (0 == buf->baddr) {
519 dprintk(1,"qbuf: mmap requested but buffer addr is zero!\n"); 523 dprintk(1, "qbuf: mmap requested "
524 "but buffer addr is zero!\n");
520 goto done; 525 goto done;
521 } 526 }
522 break; 527 break;
523 case V4L2_MEMORY_USERPTR: 528 case V4L2_MEMORY_USERPTR:
524 if (b->length < buf->bsize) { 529 if (b->length < buf->bsize) {
525 dprintk(1,"qbuf: buffer length is not enough\n"); 530 dprintk(1, "qbuf: buffer length is not enough\n");
526 goto done; 531 goto done;
527 } 532 }
528 if (VIDEOBUF_NEEDS_INIT != buf->state && buf->baddr != b->m.userptr) 533 if (VIDEOBUF_NEEDS_INIT != buf->state &&
529 q->ops->buf_release(q,buf); 534 buf->baddr != b->m.userptr)
535 q->ops->buf_release(q, buf);
530 buf->baddr = b->m.userptr; 536 buf->baddr = b->m.userptr;
531 break; 537 break;
532 case V4L2_MEMORY_OVERLAY: 538 case V4L2_MEMORY_OVERLAY:
533 buf->boff = b->m.offset; 539 buf->boff = b->m.offset;
534 break; 540 break;
535 default: 541 default:
536 dprintk(1,"qbuf: wrong memory type\n"); 542 dprintk(1, "qbuf: wrong memory type\n");
537 goto done; 543 goto done;
538 } 544 }
539 545
540 dprintk(1,"qbuf: requesting next field\n"); 546 dprintk(1, "qbuf: requesting next field\n");
541 field = videobuf_next_field(q); 547 field = videobuf_next_field(q);
542 retval = q->ops->buf_prepare(q,buf,field); 548 retval = q->ops->buf_prepare(q, buf, field);
543 if (0 != retval) { 549 if (0 != retval) {
544 dprintk(1,"qbuf: buffer_prepare returned %d\n",retval); 550 dprintk(1, "qbuf: buffer_prepare returned %d\n", retval);
545 goto done; 551 goto done;
546 } 552 }
547 553
548 list_add_tail(&buf->stream,&q->stream); 554 list_add_tail(&buf->stream, &q->stream);
549 if (q->streaming) { 555 if (q->streaming) {
550 if (q->irqlock) 556 if (q->irqlock)
551 spin_lock_irqsave(q->irqlock,flags); 557 spin_lock_irqsave(q->irqlock, flags);
552 q->ops->buf_queue(q,buf); 558 q->ops->buf_queue(q, buf);
553 if (q->irqlock) 559 if (q->irqlock)
554 spin_unlock_irqrestore(q->irqlock,flags); 560 spin_unlock_irqrestore(q->irqlock, flags);
555 } 561 }
556 dprintk(1,"qbuf: succeded\n"); 562 dprintk(1, "qbuf: succeded\n");
557 retval = 0; 563 retval = 0;
558 564
559 done: 565 done:
@@ -571,49 +577,49 @@ int videobuf_dqbuf(struct videobuf_queue *q,
571 struct videobuf_buffer *buf; 577 struct videobuf_buffer *buf;
572 int retval; 578 int retval;
573 579
574 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 580 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
575 581
576 mutex_lock(&q->lock); 582 mutex_lock(&q->lock);
577 retval = -EBUSY; 583 retval = -EBUSY;
578 if (q->reading) { 584 if (q->reading) {
579 dprintk(1,"dqbuf: Reading running...\n"); 585 dprintk(1, "dqbuf: Reading running...\n");
580 goto done; 586 goto done;
581 } 587 }
582 retval = -EINVAL; 588 retval = -EINVAL;
583 if (b->type != q->type) { 589 if (b->type != q->type) {
584 dprintk(1,"dqbuf: Wrong type.\n"); 590 dprintk(1, "dqbuf: Wrong type.\n");
585 goto done; 591 goto done;
586 } 592 }
587 if (list_empty(&q->stream)) { 593 if (list_empty(&q->stream)) {
588 dprintk(1,"dqbuf: stream running\n"); 594 dprintk(1, "dqbuf: stream running\n");
589 goto done; 595 goto done;
590 } 596 }
591 buf = list_entry(q->stream.next, struct videobuf_buffer, stream); 597 buf = list_entry(q->stream.next, struct videobuf_buffer, stream);
592 retval = videobuf_waiton(buf, nonblocking, 1); 598 retval = videobuf_waiton(buf, nonblocking, 1);
593 if (retval < 0) { 599 if (retval < 0) {
594 dprintk(1,"dqbuf: waiton returned %d\n",retval); 600 dprintk(1, "dqbuf: waiton returned %d\n", retval);
595 goto done; 601 goto done;
596 } 602 }
597 switch (buf->state) { 603 switch (buf->state) {
598 case VIDEOBUF_ERROR: 604 case VIDEOBUF_ERROR:
599 dprintk(1,"dqbuf: state is error\n"); 605 dprintk(1, "dqbuf: state is error\n");
600 retval = -EIO; 606 retval = -EIO;
601 CALL(q,sync,q, buf); 607 CALL(q, sync, q, buf);
602 buf->state = VIDEOBUF_IDLE; 608 buf->state = VIDEOBUF_IDLE;
603 break; 609 break;
604 case VIDEOBUF_DONE: 610 case VIDEOBUF_DONE:
605 dprintk(1,"dqbuf: state is done\n"); 611 dprintk(1, "dqbuf: state is done\n");
606 CALL(q,sync,q, buf); 612 CALL(q, sync, q, buf);
607 buf->state = VIDEOBUF_IDLE; 613 buf->state = VIDEOBUF_IDLE;
608 break; 614 break;
609 default: 615 default:
610 dprintk(1,"dqbuf: state invalid\n"); 616 dprintk(1, "dqbuf: state invalid\n");
611 retval = -EINVAL; 617 retval = -EINVAL;
612 goto done; 618 goto done;
613 } 619 }
614 list_del(&buf->stream); 620 list_del(&buf->stream);
615 memset(b,0,sizeof(*b)); 621 memset(b, 0, sizeof(*b));
616 videobuf_status(q,b,buf,q->type); 622 videobuf_status(q, b, buf, q->type);
617 623
618 done: 624 done:
619 mutex_unlock(&q->lock); 625 mutex_unlock(&q->lock);
@@ -623,7 +629,7 @@ int videobuf_dqbuf(struct videobuf_queue *q,
623int videobuf_streamon(struct videobuf_queue *q) 629int videobuf_streamon(struct videobuf_queue *q)
624{ 630{
625 struct videobuf_buffer *buf; 631 struct videobuf_buffer *buf;
626 unsigned long flags=0; 632 unsigned long flags = 0;
627 int retval; 633 int retval;
628 634
629 mutex_lock(&q->lock); 635 mutex_lock(&q->lock);
@@ -635,12 +641,12 @@ int videobuf_streamon(struct videobuf_queue *q)
635 goto done; 641 goto done;
636 q->streaming = 1; 642 q->streaming = 1;
637 if (q->irqlock) 643 if (q->irqlock)
638 spin_lock_irqsave(q->irqlock,flags); 644 spin_lock_irqsave(q->irqlock, flags);
639 list_for_each_entry(buf, &q->stream, stream) 645 list_for_each_entry(buf, &q->stream, stream)
640 if (buf->state == VIDEOBUF_PREPARED) 646 if (buf->state == VIDEOBUF_PREPARED)
641 q->ops->buf_queue(q,buf); 647 q->ops->buf_queue(q, buf);
642 if (q->irqlock) 648 if (q->irqlock)
643 spin_unlock_irqrestore(q->irqlock,flags); 649 spin_unlock_irqrestore(q->irqlock, flags);
644 650
645 done: 651 done:
646 mutex_unlock(&q->lock); 652 mutex_unlock(&q->lock);
@@ -676,10 +682,10 @@ static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,
676 size_t count, loff_t *ppos) 682 size_t count, loff_t *ppos)
677{ 683{
678 enum v4l2_field field; 684 enum v4l2_field field;
679 unsigned long flags=0; 685 unsigned long flags = 0;
680 int retval; 686 int retval;
681 687
682 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 688 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
683 689
684 /* setup stuff */ 690 /* setup stuff */
685 q->read_buf = videobuf_alloc(q); 691 q->read_buf = videobuf_alloc(q);
@@ -691,19 +697,19 @@ static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,
691 q->read_buf->bsize = count; 697 q->read_buf->bsize = count;
692 698
693 field = videobuf_next_field(q); 699 field = videobuf_next_field(q);
694 retval = q->ops->buf_prepare(q,q->read_buf,field); 700 retval = q->ops->buf_prepare(q, q->read_buf, field);
695 if (0 != retval) 701 if (0 != retval)
696 goto done; 702 goto done;
697 703
698 /* start capture & wait */ 704 /* start capture & wait */
699 if (q->irqlock) 705 if (q->irqlock)
700 spin_lock_irqsave(q->irqlock,flags); 706 spin_lock_irqsave(q->irqlock, flags);
701 q->ops->buf_queue(q,q->read_buf); 707 q->ops->buf_queue(q, q->read_buf);
702 if (q->irqlock) 708 if (q->irqlock)
703 spin_unlock_irqrestore(q->irqlock,flags); 709 spin_unlock_irqrestore(q->irqlock, flags);
704 retval = videobuf_waiton(q->read_buf,0,0); 710 retval = videobuf_waiton(q->read_buf, 0, 0);
705 if (0 == retval) { 711 if (0 == retval) {
706 CALL(q,sync,q,q->read_buf); 712 CALL(q, sync, q, q->read_buf);
707 if (VIDEOBUF_ERROR == q->read_buf->state) 713 if (VIDEOBUF_ERROR == q->read_buf->state)
708 retval = -EIO; 714 retval = -EIO;
709 else 715 else
@@ -712,7 +718,7 @@ static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,
712 718
713 done: 719 done:
714 /* cleanup */ 720 /* cleanup */
715 q->ops->buf_release(q,q->read_buf); 721 q->ops->buf_release(q, q->read_buf);
716 kfree(q->read_buf); 722 kfree(q->read_buf);
717 q->read_buf = NULL; 723 q->read_buf = NULL;
718 return retval; 724 return retval;
@@ -723,21 +729,21 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
723 int nonblocking) 729 int nonblocking)
724{ 730{
725 enum v4l2_field field; 731 enum v4l2_field field;
726 unsigned long flags=0; 732 unsigned long flags = 0;
727 unsigned size, nbufs; 733 unsigned size, nbufs;
728 int retval; 734 int retval;
729 735
730 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 736 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
731 737
732 mutex_lock(&q->lock); 738 mutex_lock(&q->lock);
733 739
734 nbufs = 1; size = 0; 740 nbufs = 1; size = 0;
735 q->ops->buf_setup(q,&nbufs,&size); 741 q->ops->buf_setup(q, &nbufs, &size);
736 742
737 if (NULL == q->read_buf && 743 if (NULL == q->read_buf &&
738 count >= size && 744 count >= size &&
739 !nonblocking) { 745 !nonblocking) {
740 retval = videobuf_read_zerocopy(q,data,count,ppos); 746 retval = videobuf_read_zerocopy(q, data, count, ppos);
741 if (retval >= 0 || retval == -EIO) 747 if (retval >= 0 || retval == -EIO)
742 /* ok, all done */ 748 /* ok, all done */
743 goto done; 749 goto done;
@@ -749,25 +755,25 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
749 retval = -ENOMEM; 755 retval = -ENOMEM;
750 q->read_buf = videobuf_alloc(q); 756 q->read_buf = videobuf_alloc(q);
751 757
752 dprintk(1,"video alloc=0x%p\n", q->read_buf); 758 dprintk(1, "video alloc=0x%p\n", q->read_buf);
753 if (NULL == q->read_buf) 759 if (NULL == q->read_buf)
754 goto done; 760 goto done;
755 q->read_buf->memory = V4L2_MEMORY_USERPTR; 761 q->read_buf->memory = V4L2_MEMORY_USERPTR;
756 q->read_buf->bsize = count; /* preferred size */ 762 q->read_buf->bsize = count; /* preferred size */
757 field = videobuf_next_field(q); 763 field = videobuf_next_field(q);
758 retval = q->ops->buf_prepare(q,q->read_buf,field); 764 retval = q->ops->buf_prepare(q, q->read_buf, field);
759 765
760 if (0 != retval) { 766 if (0 != retval) {
761 kfree (q->read_buf); 767 kfree(q->read_buf);
762 q->read_buf = NULL; 768 q->read_buf = NULL;
763 goto done; 769 goto done;
764 } 770 }
765 if (q->irqlock) 771 if (q->irqlock)
766 spin_lock_irqsave(q->irqlock,flags); 772 spin_lock_irqsave(q->irqlock, flags);
767 773
768 q->ops->buf_queue(q,q->read_buf); 774 q->ops->buf_queue(q, q->read_buf);
769 if (q->irqlock) 775 if (q->irqlock)
770 spin_unlock_irqrestore(q->irqlock,flags); 776 spin_unlock_irqrestore(q->irqlock, flags);
771 q->read_off = 0; 777 q->read_off = 0;
772 } 778 }
773 779
@@ -776,11 +782,11 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
776 if (0 != retval) 782 if (0 != retval)
777 goto done; 783 goto done;
778 784
779 CALL(q,sync,q,q->read_buf); 785 CALL(q, sync, q, q->read_buf);
780 786
781 if (VIDEOBUF_ERROR == q->read_buf->state) { 787 if (VIDEOBUF_ERROR == q->read_buf->state) {
782 /* catch I/O errors */ 788 /* catch I/O errors */
783 q->ops->buf_release(q,q->read_buf); 789 q->ops->buf_release(q, q->read_buf);
784 kfree(q->read_buf); 790 kfree(q->read_buf);
785 q->read_buf = NULL; 791 q->read_buf = NULL;
786 retval = -EIO; 792 retval = -EIO;
@@ -788,14 +794,14 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
788 } 794 }
789 795
790 /* Copy to userspace */ 796 /* Copy to userspace */
791 retval=CALL(q,video_copy_to_user,q,data,count,nonblocking); 797 retval = CALL(q, video_copy_to_user, q, data, count, nonblocking);
792 if (retval<0) 798 if (retval < 0)
793 goto done; 799 goto done;
794 800
795 q->read_off += retval; 801 q->read_off += retval;
796 if (q->read_off == q->read_buf->size) { 802 if (q->read_off == q->read_buf->size) {
797 /* all data copied, cleanup */ 803 /* all data copied, cleanup */
798 q->ops->buf_release(q,q->read_buf); 804 q->ops->buf_release(q, q->read_buf);
799 kfree(q->read_buf); 805 kfree(q->read_buf);
800 q->read_buf = NULL; 806 q->read_buf = NULL;
801 } 807 }
@@ -809,11 +815,11 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
809int __videobuf_read_start(struct videobuf_queue *q) 815int __videobuf_read_start(struct videobuf_queue *q)
810{ 816{
811 enum v4l2_field field; 817 enum v4l2_field field;
812 unsigned long flags=0; 818 unsigned long flags = 0;
813 unsigned int count = 0, size = 0; 819 unsigned int count = 0, size = 0;
814 int err, i; 820 int err, i;
815 821
816 q->ops->buf_setup(q,&count,&size); 822 q->ops->buf_setup(q, &count, &size);
817 if (count < 2) 823 if (count < 2)
818 count = 2; 824 count = 2;
819 if (count > VIDEO_MAX_FRAME) 825 if (count > VIDEO_MAX_FRAME)
@@ -828,17 +834,17 @@ int __videobuf_read_start(struct videobuf_queue *q)
828 834
829 for (i = 0; i < count; i++) { 835 for (i = 0; i < count; i++) {
830 field = videobuf_next_field(q); 836 field = videobuf_next_field(q);
831 err = q->ops->buf_prepare(q,q->bufs[i],field); 837 err = q->ops->buf_prepare(q, q->bufs[i], field);
832 if (err) 838 if (err)
833 return err; 839 return err;
834 list_add_tail(&q->bufs[i]->stream, &q->stream); 840 list_add_tail(&q->bufs[i]->stream, &q->stream);
835 } 841 }
836 if (q->irqlock) 842 if (q->irqlock)
837 spin_lock_irqsave(q->irqlock,flags); 843 spin_lock_irqsave(q->irqlock, flags);
838 for (i = 0; i < count; i++) 844 for (i = 0; i < count; i++)
839 q->ops->buf_queue(q,q->bufs[i]); 845 q->ops->buf_queue(q, q->bufs[i]);
840 if (q->irqlock) 846 if (q->irqlock)
841 spin_unlock_irqrestore(q->irqlock,flags); 847 spin_unlock_irqrestore(q->irqlock, flags);
842 q->reading = 1; 848 q->reading = 1;
843 return 0; 849 return 0;
844} 850}
@@ -859,7 +865,7 @@ static void __videobuf_read_stop(struct videobuf_queue *q)
859 } 865 }
860 q->read_buf = NULL; 866 q->read_buf = NULL;
861 q->reading = 0; 867 q->reading = 0;
862 868
863} 869}
864 870
865int videobuf_read_start(struct videobuf_queue *q) 871int videobuf_read_start(struct videobuf_queue *q)
@@ -899,11 +905,11 @@ ssize_t videobuf_read_stream(struct videobuf_queue *q,
899 int vbihack, int nonblocking) 905 int vbihack, int nonblocking)
900{ 906{
901 int rc, retval; 907 int rc, retval;
902 unsigned long flags=0; 908 unsigned long flags = 0;
903 909
904 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 910 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
905 911
906 dprintk(2,"%s\n",__FUNCTION__); 912 dprintk(2, "%s\n", __FUNCTION__);
907 mutex_lock(&q->lock); 913 mutex_lock(&q->lock);
908 retval = -EBUSY; 914 retval = -EBUSY;
909 if (q->streaming) 915 if (q->streaming)
@@ -932,7 +938,7 @@ ssize_t videobuf_read_stream(struct videobuf_queue *q,
932 } 938 }
933 939
934 if (q->read_buf->state == VIDEOBUF_DONE) { 940 if (q->read_buf->state == VIDEOBUF_DONE) {
935 rc = CALL (q,copy_stream, q, data + retval, count, 941 rc = CALL(q, copy_stream, q, data + retval, count,
936 retval, vbihack, nonblocking); 942 retval, vbihack, nonblocking);
937 if (rc < 0) { 943 if (rc < 0) {
938 retval = rc; 944 retval = rc;
@@ -953,10 +959,10 @@ ssize_t videobuf_read_stream(struct videobuf_queue *q,
953 list_add_tail(&q->read_buf->stream, 959 list_add_tail(&q->read_buf->stream,
954 &q->stream); 960 &q->stream);
955 if (q->irqlock) 961 if (q->irqlock)
956 spin_lock_irqsave(q->irqlock,flags); 962 spin_lock_irqsave(q->irqlock, flags);
957 q->ops->buf_queue(q,q->read_buf); 963 q->ops->buf_queue(q, q->read_buf);
958 if (q->irqlock) 964 if (q->irqlock)
959 spin_unlock_irqrestore(q->irqlock,flags); 965 spin_unlock_irqrestore(q->irqlock, flags);
960 q->read_buf = NULL; 966 q->read_buf = NULL;
961 } 967 }
962 if (retval < 0) 968 if (retval < 0)
@@ -1012,10 +1018,10 @@ int videobuf_mmap_mapper(struct videobuf_queue *q,
1012{ 1018{
1013 int retval; 1019 int retval;
1014 1020
1015 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 1021 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1016 1022
1017 mutex_lock(&q->lock); 1023 mutex_lock(&q->lock);
1018 retval=CALL(q,mmap_mapper,q,vma); 1024 retval = CALL(q, mmap_mapper, q, vma);
1019 mutex_unlock(&q->lock); 1025 mutex_unlock(&q->lock);
1020 1026
1021 return retval; 1027 return retval;
@@ -1026,15 +1032,15 @@ int videobuf_cgmbuf(struct videobuf_queue *q,
1026 struct video_mbuf *mbuf, int count) 1032 struct video_mbuf *mbuf, int count)
1027{ 1033{
1028 struct v4l2_requestbuffers req; 1034 struct v4l2_requestbuffers req;
1029 int rc,i; 1035 int rc, i;
1030 1036
1031 MAGIC_CHECK(q->int_ops->magic,MAGIC_QTYPE_OPS); 1037 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1032 1038
1033 memset(&req,0,sizeof(req)); 1039 memset(&req, 0, sizeof(req));
1034 req.type = q->type; 1040 req.type = q->type;
1035 req.count = count; 1041 req.count = count;
1036 req.memory = V4L2_MEMORY_MMAP; 1042 req.memory = V4L2_MEMORY_MMAP;
1037 rc = videobuf_reqbufs(q,&req); 1043 rc = videobuf_reqbufs(q, &req);
1038 if (rc < 0) 1044 if (rc < 0)
1039 return rc; 1045 return rc;
1040 1046
@@ -1079,9 +1085,3 @@ EXPORT_SYMBOL_GPL(videobuf_poll_stream);
1079EXPORT_SYMBOL_GPL(videobuf_mmap_setup); 1085EXPORT_SYMBOL_GPL(videobuf_mmap_setup);
1080EXPORT_SYMBOL_GPL(videobuf_mmap_free); 1086EXPORT_SYMBOL_GPL(videobuf_mmap_free);
1081EXPORT_SYMBOL_GPL(videobuf_mmap_mapper); 1087EXPORT_SYMBOL_GPL(videobuf_mmap_mapper);
1082
1083/*
1084 * Local variables:
1085 * c-basic-offset: 8
1086 * End:
1087 */