tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

V4L/DVB (6600): V4L: videobuf: don't chew up namespace STATE_.*, convert to VIDEOBUF_

s/STATE_NEEDS_INIT/VIDEOBUF_NEEDS_INIT/g
s/STATE_PREPARED/VIDEOBUF_PREPARED/g
s/STATE_QUEUED/VIDEOBUF_QUEUED/g
s/STATE_ACTIVE/VIDEOBUF_ACTIVE/g
s/STATE_DONE/VIDEOBUF_DONE/g
s/STATE_ERROR/VIDEOBUF_ERROR/g
s/STATE_IDLE/VIDEOBUF_IDLE/g

Signed-off-by: Brandon Philips <bphilips@suse.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

authored by

Brandon Philips and committed by
Mauro Carvalho Chehab 0fc0686e 1414becf

+134 -134
+4 -4
drivers/media/common/saa7146_fops.c
··· 61 61 videobuf_waiton(&buf->vb,0,0); 62 62 videobuf_dma_unmap(q, dma); 63 63 videobuf_dma_free(dma); 64 - buf->vb.state = STATE_NEEDS_INIT; 64 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 65 65 } 66 66 67 67 ··· 83 83 buf->activate(dev,buf,NULL); 84 84 } else { 85 85 list_add_tail(&buf->vb.queue,&q->queue); 86 - buf->vb.state = STATE_QUEUED; 86 + buf->vb.state = VIDEOBUF_QUEUED; 87 87 DEB_D(("adding buffer %p to queue. (active buffer present)\n", buf)); 88 88 } 89 89 return 0; ··· 174 174 spin_lock_irqsave(&dev->slock,flags); 175 175 if (q->curr) { 176 176 DEB_D(("timeout on %p\n", q->curr)); 177 - saa7146_buffer_finish(dev,q,STATE_ERROR); 177 + saa7146_buffer_finish(dev,q,VIDEOBUF_ERROR); 178 178 } 179 179 180 180 /* we don't restart the transfer here like other drivers do. when ··· 366 366 } 367 367 368 368 poll_wait(file, &buf->done, wait); 369 - if (buf->state == STATE_DONE || buf->state == STATE_ERROR) { 369 + if (buf->state == VIDEOBUF_DONE || buf->state == VIDEOBUF_ERROR) { 370 370 DEB_D(("poll succeeded!\n")); 371 371 return POLLIN|POLLRDNORM; 372 372 }
+5 -5
drivers/media/common/saa7146_vbi.c
··· 205 205 struct saa7146_buf *next) 206 206 { 207 207 struct saa7146_vv *vv = dev->vv_data; 208 - buf->vb.state = STATE_ACTIVE; 208 + buf->vb.state = VIDEOBUF_ACTIVE; 209 209 210 210 DEB_VBI(("dev:%p, buf:%p, next:%p\n",dev,buf,next)); 211 211 saa7146_set_vbi_capture(dev,buf,next); ··· 238 238 if (buf->vb.size != size) 239 239 saa7146_dma_free(dev,q,buf); 240 240 241 - if (STATE_NEEDS_INIT == buf->vb.state) { 241 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 242 242 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 243 243 244 244 buf->vb.width = llength; ··· 257 257 if (0 != err) 258 258 return err; 259 259 } 260 - buf->vb.state = STATE_PREPARED; 260 + buf->vb.state = VIDEOBUF_PREPARED; 261 261 buf->activate = buffer_activate; 262 262 263 263 return 0; ··· 335 335 saa7146_write(dev, MC1, MASK_20); 336 336 337 337 if (vv->vbi_q.curr) { 338 - saa7146_buffer_finish(dev,&vv->vbi_q,STATE_DONE); 338 + saa7146_buffer_finish(dev,&vv->vbi_q,VIDEOBUF_DONE); 339 339 } 340 340 341 341 videobuf_queue_cancel(&fh->vbi_q); ··· 458 458 /* this must be += 2, one count for each field */ 459 459 vv->vbi_fieldcount+=2; 460 460 vv->vbi_q.curr->vb.field_count = vv->vbi_fieldcount; 461 - saa7146_buffer_finish(dev,&vv->vbi_q,STATE_DONE); 461 + saa7146_buffer_finish(dev,&vv->vbi_q,VIDEOBUF_DONE); 462 462 } else { 463 463 DEB_VBI(("dev:%p\n",dev)); 464 464 }
+4 -4
drivers/media/common/saa7146_video.c
··· 1235 1235 { 1236 1236 struct saa7146_vv *vv = dev->vv_data; 1237 1237 1238 - buf->vb.state = STATE_ACTIVE; 1238 + buf->vb.state = VIDEOBUF_ACTIVE; 1239 1239 saa7146_set_capture(dev,buf,next); 1240 1240 1241 1241 mod_timer(&vv->video_q.timeout, jiffies+BUFFER_TIMEOUT); ··· 1281 1281 saa7146_dma_free(dev,q,buf); 1282 1282 } 1283 1283 1284 - if (STATE_NEEDS_INIT == buf->vb.state) { 1284 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1285 1285 struct saa7146_format *sfmt; 1286 1286 1287 1287 buf->vb.bytesperline = fh->video_fmt.bytesperline; ··· 1314 1314 if (err) 1315 1315 goto oops; 1316 1316 } 1317 - buf->vb.state = STATE_PREPARED; 1317 + buf->vb.state = VIDEOBUF_PREPARED; 1318 1318 buf->activate = buffer_activate; 1319 1319 1320 1320 return 0; ··· 1453 1453 1454 1454 /* only finish the buffer if we have one... */ 1455 1455 if( NULL != q->curr ) { 1456 - saa7146_buffer_finish(dev,q,STATE_DONE); 1456 + saa7146_buffer_finish(dev,q,VIDEOBUF_DONE); 1457 1457 } 1458 1458 saa7146_buffer_next(dev,q,0); 1459 1459
+13 -13
drivers/media/video/bt8xx/bttv-driver.c
··· 1638 1638 1639 1639 dprintk("switch_overlay: enter [new=%p]\n",new); 1640 1640 if (new) 1641 - new->vb.state = STATE_DONE; 1641 + new->vb.state = VIDEOBUF_DONE; 1642 1642 spin_lock_irqsave(&btv->s_lock,flags); 1643 1643 old = btv->screen; 1644 1644 btv->screen = new; ··· 1749 1749 } 1750 1750 1751 1751 /* alloc risc memory */ 1752 - if (STATE_NEEDS_INIT == buf->vb.state) { 1752 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1753 1753 redo_dma_risc = 1; 1754 1754 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf))) 1755 1755 goto fail; ··· 1759 1759 if (0 != (rc = bttv_buffer_risc(btv,buf))) 1760 1760 goto fail; 1761 1761 1762 - buf->vb.state = STATE_PREPARED; 1762 + buf->vb.state = VIDEOBUF_PREPARED; 1763 1763 return 0; 1764 1764 1765 1765 fail: ··· 1798 1798 struct bttv_fh *fh = q->priv_data; 1799 1799 struct bttv *btv = fh->btv; 1800 1800 1801 - buf->vb.state = STATE_QUEUED; 1801 + buf->vb.state = VIDEOBUF_QUEUED; 1802 1802 list_add_tail(&buf->vb.queue,&btv->capture); 1803 1803 if (!btv->curr.frame_irq) { 1804 1804 btv->loop_irq |= 1; ··· 3102 3102 } 3103 3103 3104 3104 poll_wait(file, &buf->vb.done, wait); 3105 - if (buf->vb.state == STATE_DONE || 3106 - buf->vb.state == STATE_ERROR) 3105 + if (buf->vb.state == VIDEOBUF_DONE || 3106 + buf->vb.state == VIDEOBUF_ERROR) 3107 3107 return POLLIN|POLLRDNORM; 3108 3108 return 0; 3109 3109 } ··· 3699 3699 bttv_set_dma(btv, 0); 3700 3700 3701 3701 /* wake up */ 3702 - bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR); 3703 - bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR); 3702 + bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR); 3703 + bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR); 3704 3704 3705 3705 /* cancel all outstanding capture / vbi requests */ 3706 3706 while (!list_empty(&btv->capture)) { 3707 3707 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue); 3708 3708 list_del(&item->vb.queue); 3709 - item->vb.state = STATE_ERROR; 3709 + item->vb.state = VIDEOBUF_ERROR; 3710 3710 wake_up(&item->vb.done); 3711 3711 } 3712 3712 while (!list_empty(&btv->vcapture)) { 3713 3713 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue); 3714 3714 list_del(&item->vb.queue); 3715 - item->vb.state = STATE_ERROR; 3715 + item->vb.state = VIDEOBUF_ERROR; 3716 3716 wake_up(&item->vb.done); 3717 3717 } 3718 3718 ··· 3735 3735 3736 3736 do_gettimeofday(&wakeup->vb.ts); 3737 3737 wakeup->vb.field_count = btv->field_count; 3738 - wakeup->vb.state = STATE_DONE; 3738 + wakeup->vb.state = VIDEOBUF_DONE; 3739 3739 wake_up(&wakeup->vb.done); 3740 3740 spin_unlock(&btv->s_lock); 3741 3741 } ··· 3784 3784 } 3785 3785 3786 3786 /* wake up finished buffers */ 3787 - bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE); 3787 + bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE); 3788 3788 spin_unlock(&btv->s_lock); 3789 3789 } 3790 3790 ··· 3817 3817 bttv_buffer_activate_vbi(btv, new); 3818 3818 bttv_set_dma(btv, 0); 3819 3819 3820 - bttv_irq_wakeup_vbi(btv, old, STATE_DONE); 3820 + bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE); 3821 3821 spin_unlock(&btv->s_lock); 3822 3822 } 3823 3823
+7 -7
drivers/media/video/bt8xx/bttv-risc.c
··· 582 582 videobuf_dma_free(dma); 583 583 btcx_riscmem_free(btv->c.pci,&buf->bottom); 584 584 btcx_riscmem_free(btv->c.pci,&buf->top); 585 - buf->vb.state = STATE_NEEDS_INIT; 585 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 586 586 } 587 587 588 588 int ··· 602 602 if (vbi) { 603 603 unsigned int crop, vdelay; 604 604 605 - vbi->vb.state = STATE_ACTIVE; 605 + vbi->vb.state = VIDEOBUF_ACTIVE; 606 606 list_del(&vbi->vb.queue); 607 607 608 608 /* VDELAY is start of video, end of VBI capturing. */ ··· 644 644 /* video capture */ 645 645 if (NULL != set->top && NULL != set->bottom) { 646 646 if (set->top == set->bottom) { 647 - set->top->vb.state = STATE_ACTIVE; 647 + set->top->vb.state = VIDEOBUF_ACTIVE; 648 648 if (set->top->vb.queue.next) 649 649 list_del(&set->top->vb.queue); 650 650 } else { 651 - set->top->vb.state = STATE_ACTIVE; 652 - set->bottom->vb.state = STATE_ACTIVE; 651 + set->top->vb.state = VIDEOBUF_ACTIVE; 652 + set->bottom->vb.state = VIDEOBUF_ACTIVE; 653 653 if (set->top->vb.queue.next) 654 654 list_del(&set->top->vb.queue); 655 655 if (set->bottom->vb.queue.next) ··· 666 666 btaor((set->top->btswap & 0x0a) | (set->bottom->btswap & 0x05), 667 667 ~0x0f, BT848_COLOR_CTL); 668 668 } else if (NULL != set->top) { 669 - set->top->vb.state = STATE_ACTIVE; 669 + set->top->vb.state = VIDEOBUF_ACTIVE; 670 670 if (set->top->vb.queue.next) 671 671 list_del(&set->top->vb.queue); 672 672 bttv_apply_geo(btv, &set->top->geo,1); ··· 677 677 btaor(set->top->btformat & 0xff, ~0xff, BT848_COLOR_FMT); 678 678 btaor(set->top->btswap & 0x0f, ~0x0f, BT848_COLOR_CTL); 679 679 } else if (NULL != set->bottom) { 680 - set->bottom->vb.state = STATE_ACTIVE; 680 + set->bottom->vb.state = VIDEOBUF_ACTIVE; 681 681 if (set->bottom->vb.queue.next) 682 682 list_del(&set->bottom->vb.queue); 683 683 bttv_apply_geo(btv, &set->bottom->geo,1);
+3 -3
drivers/media/video/bt8xx/bttv-vbi.c
··· 142 142 redo_dma_risc = 1; 143 143 } 144 144 145 - if (STATE_NEEDS_INIT == buf->vb.state) { 145 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 146 146 redo_dma_risc = 1; 147 147 if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL))) 148 148 goto fail; ··· 189 189 /* For bttv_buffer_activate_vbi(). */ 190 190 buf->geo.vdelay = min_vdelay; 191 191 192 - buf->vb.state = STATE_PREPARED; 192 + buf->vb.state = VIDEOBUF_PREPARED; 193 193 buf->vb.field = field; 194 194 dprintk("buf prepare %p: top=%p bottom=%p field=%s\n", 195 195 vb, &buf->top, &buf->bottom, ··· 209 209 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 210 210 211 211 dprintk("queue %p\n",vb); 212 - buf->vb.state = STATE_QUEUED; 212 + buf->vb.state = VIDEOBUF_QUEUED; 213 213 list_add_tail(&buf->vb.queue,&btv->vcapture); 214 214 if (NULL == btv->cvbi) { 215 215 fh->btv->loop_irq |= 4;
+9 -9
drivers/media/video/cx23885/cx23885-core.c
··· 378 378 do_gettimeofday(&buf->vb.ts); 379 379 dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i, 380 380 count, buf->count); 381 - buf->vb.state = STATE_DONE; 381 + buf->vb.state = VIDEOBUF_DONE; 382 382 list_del(&buf->vb.queue); 383 383 wake_up(&buf->vb.done); 384 384 } ··· 972 972 videobuf_dma_unmap(q, dma); 973 973 videobuf_dma_free(dma); 974 974 btcx_riscmem_free((struct pci_dev *)q->dev, &buf->risc); 975 - buf->vb.state = STATE_NEEDS_INIT; 975 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 976 976 } 977 977 978 978 static int cx23885_start_dma(struct cx23885_tsport *port, ··· 1075 1075 list_del(&buf->vb.queue); 1076 1076 list_add_tail(&buf->vb.queue, &q->active); 1077 1077 cx23885_start_dma(port, q, buf); 1078 - buf->vb.state = STATE_ACTIVE; 1078 + buf->vb.state = VIDEOBUF_ACTIVE; 1079 1079 buf->count = q->count++; 1080 1080 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); 1081 1081 dprintk(5, "[%p/%d] restart_queue - first active\n", ··· 1086 1086 prev->fmt == buf->fmt) { 1087 1087 list_del(&buf->vb.queue); 1088 1088 list_add_tail(&buf->vb.queue, &q->active); 1089 - buf->vb.state = STATE_ACTIVE; 1089 + buf->vb.state = VIDEOBUF_ACTIVE; 1090 1090 buf->count = q->count++; 1091 1091 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 1092 1092 prev->risc.jmp[2] = cpu_to_le32(0); /* 64 bit bits 63-32 */ ··· 1123 1123 if (0 != buf->vb.baddr && buf->vb.bsize < size) 1124 1124 return -EINVAL; 1125 1125 1126 - if (STATE_NEEDS_INIT == buf->vb.state) { 1126 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1127 1127 buf->vb.width = port->ts_packet_size; 1128 1128 buf->vb.height = port->ts_packet_count; 1129 1129 buf->vb.size = size; ··· 1135 1135 videobuf_to_dma(&buf->vb)->sglist, 1136 1136 buf->vb.width, buf->vb.height); 1137 1137 } 1138 - buf->vb.state = STATE_PREPARED; 1138 + buf->vb.state = VIDEOBUF_PREPARED; 1139 1139 return 0; 1140 1140 1141 1141 fail: ··· 1158 1158 dprintk( 1, "queue is empty - first active\n" ); 1159 1159 list_add_tail(&buf->vb.queue, &cx88q->active); 1160 1160 cx23885_start_dma(port, cx88q, buf); 1161 - buf->vb.state = STATE_ACTIVE; 1161 + buf->vb.state = VIDEOBUF_ACTIVE; 1162 1162 buf->count = cx88q->count++; 1163 1163 mod_timer(&cx88q->timeout, jiffies + BUFFER_TIMEOUT); 1164 1164 dprintk(1, "[%p/%d] %s - first active\n", ··· 1168 1168 prev = list_entry(cx88q->active.prev, struct cx23885_buffer, 1169 1169 vb.queue); 1170 1170 list_add_tail(&buf->vb.queue, &cx88q->active); 1171 - buf->vb.state = STATE_ACTIVE; 1171 + buf->vb.state = VIDEOBUF_ACTIVE; 1172 1172 buf->count = cx88q->count++; 1173 1173 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 1174 1174 prev->risc.jmp[2] = cpu_to_le32(0); /* 64 bit bits 63-32 */ ··· 1192 1192 buf = list_entry(q->active.next, struct cx23885_buffer, 1193 1193 vb.queue); 1194 1194 list_del(&buf->vb.queue); 1195 - buf->vb.state = STATE_ERROR; 1195 + buf->vb.state = VIDEOBUF_ERROR; 1196 1196 wake_up(&buf->vb.done); 1197 1197 dprintk(1, "[%p/%d] %s - dma=0x%08lx\n", 1198 1198 buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
+1 -1
drivers/media/video/cx88/cx88-alsa.c
··· 417 417 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP|RISC_IRQ1|RISC_CNT_INC); 418 418 buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 419 419 420 - buf->vb.state = STATE_PREPARED; 420 + buf->vb.state = VIDEOBUF_PREPARED; 421 421 422 422 chip->buf = buf; 423 423 chip->dma_risc = dma;
+2 -2
drivers/media/video/cx88/cx88-core.c
··· 220 220 videobuf_dma_unmap(q, dma); 221 221 videobuf_dma_free(dma); 222 222 btcx_riscmem_free((struct pci_dev *)q->dev, &buf->risc); 223 - buf->vb.state = STATE_NEEDS_INIT; 223 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 224 224 } 225 225 226 226 /* ------------------------------------------------------------------ */ ··· 538 538 do_gettimeofday(&buf->vb.ts); 539 539 dprintk(2,"[%p/%d] wakeup reg=%d buf=%d\n",buf,buf->vb.i, 540 540 count, buf->count); 541 - buf->vb.state = STATE_DONE; 541 + buf->vb.state = VIDEOBUF_DONE; 542 542 list_del(&buf->vb.queue); 543 543 wake_up(&buf->vb.done); 544 544 }
+7 -7
drivers/media/video/cx88/cx88-mpeg.c
··· 195 195 list_del(&buf->vb.queue); 196 196 list_add_tail(&buf->vb.queue,&q->active); 197 197 cx8802_start_dma(dev, q, buf); 198 - buf->vb.state = STATE_ACTIVE; 198 + buf->vb.state = VIDEOBUF_ACTIVE; 199 199 buf->count = q->count++; 200 200 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); 201 201 dprintk(1,"[%p/%d] restart_queue - first active\n", ··· 206 206 prev->fmt == buf->fmt) { 207 207 list_del(&buf->vb.queue); 208 208 list_add_tail(&buf->vb.queue,&q->active); 209 - buf->vb.state = STATE_ACTIVE; 209 + buf->vb.state = VIDEOBUF_ACTIVE; 210 210 buf->count = q->count++; 211 211 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 212 212 dprintk(1,"[%p/%d] restart_queue - move to active\n", ··· 242 242 if (0 != buf->vb.baddr && buf->vb.bsize < size) 243 243 return -EINVAL; 244 244 245 - if (STATE_NEEDS_INIT == buf->vb.state) { 245 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 246 246 buf->vb.width = dev->ts_packet_size; 247 247 buf->vb.height = dev->ts_packet_count; 248 248 buf->vb.size = size; ··· 254 254 dma->sglist, 255 255 buf->vb.width, buf->vb.height, 0); 256 256 } 257 - buf->vb.state = STATE_PREPARED; 257 + buf->vb.state = VIDEOBUF_PREPARED; 258 258 return 0; 259 259 260 260 fail: ··· 276 276 dprintk( 1, "queue is empty - first active\n" ); 277 277 list_add_tail(&buf->vb.queue,&cx88q->active); 278 278 cx8802_start_dma(dev, cx88q, buf); 279 - buf->vb.state = STATE_ACTIVE; 279 + buf->vb.state = VIDEOBUF_ACTIVE; 280 280 buf->count = cx88q->count++; 281 281 mod_timer(&cx88q->timeout, jiffies+BUFFER_TIMEOUT); 282 282 dprintk(1,"[%p/%d] %s - first active\n", ··· 286 286 dprintk( 1, "queue is not empty - append to active\n" ); 287 287 prev = list_entry(cx88q->active.prev, struct cx88_buffer, vb.queue); 288 288 list_add_tail(&buf->vb.queue,&cx88q->active); 289 - buf->vb.state = STATE_ACTIVE; 289 + buf->vb.state = VIDEOBUF_ACTIVE; 290 290 buf->count = cx88q->count++; 291 291 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 292 292 dprintk( 1, "[%p/%d] %s - append to active\n", ··· 306 306 while (!list_empty(&q->active)) { 307 307 buf = list_entry(q->active.next, struct cx88_buffer, vb.queue); 308 308 list_del(&buf->vb.queue); 309 - buf->vb.state = STATE_ERROR; 309 + buf->vb.state = VIDEOBUF_ERROR; 310 310 wake_up(&buf->vb.done); 311 311 dprintk(1,"[%p/%d] %s - dma=0x%08lx\n", 312 312 buf, buf->vb.i, reason, (unsigned long)buf->risc.dma);
+5 -5
drivers/media/video/cx88/cx88-vbi.c
··· 130 130 while (!list_empty(&q->active)) { 131 131 buf = list_entry(q->active.next, struct cx88_buffer, vb.queue); 132 132 list_del(&buf->vb.queue); 133 - buf->vb.state = STATE_ERROR; 133 + buf->vb.state = VIDEOBUF_ERROR; 134 134 wake_up(&buf->vb.done); 135 135 printk("%s/0: [%p/%d] timeout - dma=0x%08lx\n", dev->core->name, 136 136 buf, buf->vb.i, (unsigned long)buf->risc.dma); ··· 168 168 if (0 != buf->vb.baddr && buf->vb.bsize < size) 169 169 return -EINVAL; 170 170 171 - if (STATE_NEEDS_INIT == buf->vb.state) { 171 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 172 172 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 173 173 buf->vb.width = VBI_LINE_LENGTH; 174 174 buf->vb.height = VBI_LINE_COUNT; ··· 183 183 buf->vb.width, 0, 184 184 buf->vb.height); 185 185 } 186 - buf->vb.state = STATE_PREPARED; 186 + buf->vb.state = VIDEOBUF_PREPARED; 187 187 return 0; 188 188 189 189 fail: ··· 207 207 if (list_empty(&q->active)) { 208 208 list_add_tail(&buf->vb.queue,&q->active); 209 209 cx8800_start_vbi_dma(dev, q, buf); 210 - buf->vb.state = STATE_ACTIVE; 210 + buf->vb.state = VIDEOBUF_ACTIVE; 211 211 buf->count = q->count++; 212 212 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); 213 213 dprintk(2,"[%p/%d] vbi_queue - first active\n", ··· 216 216 } else { 217 217 prev = list_entry(q->active.prev, struct cx88_buffer, vb.queue); 218 218 list_add_tail(&buf->vb.queue,&q->active); 219 - buf->vb.state = STATE_ACTIVE; 219 + buf->vb.state = VIDEOBUF_ACTIVE; 220 220 buf->count = q->count++; 221 221 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 222 222 dprintk(2,"[%p/%d] buffer_queue - append to active\n",
+11 -11
drivers/media/video/cx88/cx88-video.c
··· 486 486 if (NULL == prev) { 487 487 list_move_tail(&buf->vb.queue, &q->active); 488 488 start_video_dma(dev, q, buf); 489 - buf->vb.state = STATE_ACTIVE; 489 + buf->vb.state = VIDEOBUF_ACTIVE; 490 490 buf->count = q->count++; 491 491 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); 492 492 dprintk(2,"[%p/%d] restart_queue - first active\n", ··· 496 496 prev->vb.height == buf->vb.height && 497 497 prev->fmt == buf->fmt) { 498 498 list_move_tail(&buf->vb.queue, &q->active); 499 - buf->vb.state = STATE_ACTIVE; 499 + buf->vb.state = VIDEOBUF_ACTIVE; 500 500 buf->count = q->count++; 501 501 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 502 502 dprintk(2,"[%p/%d] restart_queue - move to active\n", ··· 553 553 init_buffer = 1; 554 554 } 555 555 556 - if (STATE_NEEDS_INIT == buf->vb.state) { 556 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 557 557 init_buffer = 1; 558 558 if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL))) 559 559 goto fail; ··· 601 601 fh->width, fh->height, fh->fmt->depth, fh->fmt->name, 602 602 (unsigned long)buf->risc.dma); 603 603 604 - buf->vb.state = STATE_PREPARED; 604 + buf->vb.state = VIDEOBUF_PREPARED; 605 605 return 0; 606 606 607 607 fail: ··· 625 625 626 626 if (!list_empty(&q->queued)) { 627 627 list_add_tail(&buf->vb.queue,&q->queued); 628 - buf->vb.state = STATE_QUEUED; 628 + buf->vb.state = VIDEOBUF_QUEUED; 629 629 dprintk(2,"[%p/%d] buffer_queue - append to queued\n", 630 630 buf, buf->vb.i); 631 631 632 632 } else if (list_empty(&q->active)) { 633 633 list_add_tail(&buf->vb.queue,&q->active); 634 634 start_video_dma(dev, q, buf); 635 - buf->vb.state = STATE_ACTIVE; 635 + buf->vb.state = VIDEOBUF_ACTIVE; 636 636 buf->count = q->count++; 637 637 mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); 638 638 dprintk(2,"[%p/%d] buffer_queue - first active\n", ··· 644 644 prev->vb.height == buf->vb.height && 645 645 prev->fmt == buf->fmt) { 646 646 list_add_tail(&buf->vb.queue,&q->active); 647 - buf->vb.state = STATE_ACTIVE; 647 + buf->vb.state = VIDEOBUF_ACTIVE; 648 648 buf->count = q->count++; 649 649 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 650 650 dprintk(2,"[%p/%d] buffer_queue - append to active\n", ··· 652 652 653 653 } else { 654 654 list_add_tail(&buf->vb.queue,&q->queued); 655 - buf->vb.state = STATE_QUEUED; 655 + buf->vb.state = VIDEOBUF_QUEUED; 656 656 dprintk(2,"[%p/%d] buffer_queue - first queued\n", 657 657 buf, buf->vb.i); 658 658 } ··· 822 822 return POLLERR; 823 823 } 824 824 poll_wait(file, &buf->vb.done, wait); 825 - if (buf->vb.state == STATE_DONE || 826 - buf->vb.state == STATE_ERROR) 825 + if (buf->vb.state == VIDEOBUF_DONE || 826 + buf->vb.state == VIDEOBUF_ERROR) 827 827 return POLLIN|POLLRDNORM; 828 828 return 0; 829 829 } ··· 1496 1496 while (!list_empty(&q->active)) { 1497 1497 buf = list_entry(q->active.next, struct cx88_buffer, vb.queue); 1498 1498 list_del(&buf->vb.queue); 1499 - buf->vb.state = STATE_ERROR; 1499 + buf->vb.state = VIDEOBUF_ERROR; 1500 1500 wake_up(&buf->vb.done); 1501 1501 printk("%s/0: [%p/%d] timeout - dma=0x%08lx\n", core->name, 1502 1502 buf, buf->vb.i, (unsigned long)buf->risc.dma);
+4 -4
drivers/media/video/saa7134/saa7134-core.c
··· 294 294 videobuf_waiton(&buf->vb,0,0); 295 295 videobuf_dma_unmap(q, dma); 296 296 videobuf_dma_free(dma); 297 - buf->vb.state = STATE_NEEDS_INIT; 297 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 298 298 } 299 299 300 300 /* ------------------------------------------------------------------ */ ··· 313 313 buf->activate(dev,buf,NULL); 314 314 } else if (list_empty(&q->queue)) { 315 315 list_add_tail(&buf->vb.queue,&q->queue); 316 - buf->vb.state = STATE_QUEUED; 316 + buf->vb.state = VIDEOBUF_QUEUED; 317 317 } else { 318 318 next = list_entry(q->queue.next,struct saa7134_buf, 319 319 vb.queue); ··· 322 322 } 323 323 } else { 324 324 list_add_tail(&buf->vb.queue,&q->queue); 325 - buf->vb.state = STATE_QUEUED; 325 + buf->vb.state = VIDEOBUF_QUEUED; 326 326 } 327 327 return 0; 328 328 } ··· 387 387 try to start over with the next one. */ 388 388 if (q->curr) { 389 389 dprintk("timeout on %p\n",q->curr); 390 - saa7134_buffer_finish(dev,q,STATE_ERROR); 390 + saa7134_buffer_finish(dev,q,VIDEOBUF_ERROR); 391 391 } 392 392 saa7134_buffer_next(dev,q); 393 393 spin_unlock_irqrestore(&dev->slock,flags);
+4 -4
drivers/media/video/saa7134/saa7134-ts.c
··· 47 47 { 48 48 49 49 dprintk("buffer_activate [%p]",buf); 50 - buf->vb.state = STATE_ACTIVE; 50 + buf->vb.state = VIDEOBUF_ACTIVE; 51 51 buf->top_seen = 0; 52 52 53 53 if (NULL == next) ··· 91 91 saa7134_dma_free(q,buf); 92 92 } 93 93 94 - if (STATE_NEEDS_INIT == buf->vb.state) { 94 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 95 95 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 96 96 97 97 buf->vb.width = llength; ··· 121 121 saa_writel(SAA7134_RS_PITCH(5),TS_PACKET_SIZE); 122 122 saa_writel(SAA7134_RS_CONTROL(5),control); 123 123 124 - buf->vb.state = STATE_PREPARED; 124 + buf->vb.state = VIDEOBUF_PREPARED; 125 125 buf->activate = buffer_activate; 126 126 buf->vb.field = field; 127 127 return 0; ··· 242 242 if ((status & 0x100000) != 0x100000) 243 243 goto done; 244 244 } 245 - saa7134_buffer_finish(dev,&dev->ts_q,STATE_DONE); 245 + saa7134_buffer_finish(dev,&dev->ts_q,VIDEOBUF_DONE); 246 246 } 247 247 saa7134_buffer_next(dev,&dev->ts_q); 248 248
+4 -4
drivers/media/video/saa7134/saa7134-vbi.c
··· 85 85 unsigned long control,base; 86 86 87 87 dprintk("buffer_activate [%p]\n",buf); 88 - buf->vb.state = STATE_ACTIVE; 88 + buf->vb.state = VIDEOBUF_ACTIVE; 89 89 buf->top_seen = 0; 90 90 91 91 task_init(dev,buf,TASK_A); ··· 136 136 if (buf->vb.size != size) 137 137 saa7134_dma_free(q,buf); 138 138 139 - if (STATE_NEEDS_INIT == buf->vb.state) { 139 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 140 140 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 141 141 142 142 buf->vb.width = llength; ··· 154 154 if (err) 155 155 goto oops; 156 156 } 157 - buf->vb.state = STATE_PREPARED; 157 + buf->vb.state = VIDEOBUF_PREPARED; 158 158 buf->activate = buffer_activate; 159 159 buf->vb.field = field; 160 160 return 0; ··· 240 240 goto done; 241 241 242 242 dev->vbi_q.curr->vb.field_count = dev->vbi_fieldcount; 243 - saa7134_buffer_finish(dev,&dev->vbi_q,STATE_DONE); 243 + saa7134_buffer_finish(dev,&dev->vbi_q,VIDEOBUF_DONE); 244 244 } 245 245 saa7134_buffer_next(dev,&dev->vbi_q); 246 246
+6 -6
drivers/media/video/saa7134/saa7134-video.c
··· 945 945 unsigned long bpl_uv,lines_uv,base2,base3,tmp; /* planar */ 946 946 947 947 dprintk("buffer_activate buf=%p\n",buf); 948 - buf->vb.state = STATE_ACTIVE; 948 + buf->vb.state = VIDEOBUF_ACTIVE; 949 949 buf->top_seen = 0; 950 950 951 951 set_size(dev,TASK_A,buf->vb.width,buf->vb.height, ··· 1054 1054 saa7134_dma_free(q,buf); 1055 1055 } 1056 1056 1057 - if (STATE_NEEDS_INIT == buf->vb.state) { 1057 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1058 1058 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 1059 1059 1060 1060 buf->vb.width = fh->width; ··· 1074 1074 if (err) 1075 1075 goto oops; 1076 1076 } 1077 - buf->vb.state = STATE_PREPARED; 1077 + buf->vb.state = VIDEOBUF_PREPARED; 1078 1078 buf->activate = buffer_activate; 1079 1079 return 0; 1080 1080 ··· 1421 1421 return POLLERR; 1422 1422 1423 1423 poll_wait(file, &buf->done, wait); 1424 - if (buf->state == STATE_DONE || 1425 - buf->state == STATE_ERROR) 1424 + if (buf->state == VIDEOBUF_DONE || 1425 + buf->state == VIDEOBUF_ERROR) 1426 1426 return POLLIN|POLLRDNORM; 1427 1427 return 0; 1428 1428 } ··· 2519 2519 goto done; 2520 2520 } 2521 2521 dev->video_q.curr->vb.field_count = dev->video_fieldcount; 2522 - saa7134_buffer_finish(dev,&dev->video_q,STATE_DONE); 2522 + saa7134_buffer_finish(dev,&dev->video_q,VIDEOBUF_DONE); 2523 2523 } 2524 2524 saa7134_buffer_next(dev,&dev->video_q); 2525 2525
+25 -25
drivers/media/video/videobuf-core.c
··· 68 68 69 69 MAGIC_CHECK(vb->magic,MAGIC_BUFFER); 70 70 add_wait_queue(&vb->done, &wait); 71 - while (vb->state == STATE_ACTIVE || vb->state == STATE_QUEUED) { 71 + while (vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) { 72 72 if (non_blocking) { 73 73 retval = -EAGAIN; 74 74 break; 75 75 } 76 76 set_current_state(intr ? TASK_INTERRUPTIBLE 77 77 : TASK_UNINTERRUPTIBLE); 78 - if (vb->state == STATE_ACTIVE || vb->state == STATE_QUEUED) 78 + if (vb->state == VIDEOBUF_ACTIVE || vb->state == VIDEOBUF_QUEUED) 79 79 schedule(); 80 80 set_current_state(TASK_RUNNING); 81 81 if (intr && signal_pending(current)) { ··· 167 167 dprintk(1,"busy: buffer #%d mapped\n",i); 168 168 return 1; 169 169 } 170 - if (q->bufs[i]->state == STATE_QUEUED) { 170 + if (q->bufs[i]->state == VIDEOBUF_QUEUED) { 171 171 dprintk(1,"busy: buffer #%d queued\n",i); 172 172 return 1; 173 173 } 174 - if (q->bufs[i]->state == STATE_ACTIVE) { 174 + if (q->bufs[i]->state == VIDEOBUF_ACTIVE) { 175 175 dprintk(1,"busy: buffer #%d avtive\n",i); 176 176 return 1; 177 177 } ··· 191 191 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 192 192 if (NULL == q->bufs[i]) 193 193 continue; 194 - if (q->bufs[i]->state == STATE_QUEUED) { 194 + if (q->bufs[i]->state == VIDEOBUF_QUEUED) { 195 195 list_del(&q->bufs[i]->queue); 196 - q->bufs[i]->state = STATE_ERROR; 196 + q->bufs[i]->state = VIDEOBUF_ERROR; 197 197 } 198 198 } 199 199 if (q->irqlock) ··· 259 259 b->flags |= V4L2_BUF_FLAG_MAPPED; 260 260 261 261 switch (vb->state) { 262 - case STATE_PREPARED: 263 - case STATE_QUEUED: 264 - case STATE_ACTIVE: 262 + case VIDEOBUF_PREPARED: 263 + case VIDEOBUF_QUEUED: 264 + case VIDEOBUF_ACTIVE: 265 265 b->flags |= V4L2_BUF_FLAG_QUEUED; 266 266 break; 267 - case STATE_DONE: 268 - case STATE_ERROR: 267 + case VIDEOBUF_DONE: 268 + case VIDEOBUF_ERROR: 269 269 b->flags |= V4L2_BUF_FLAG_DONE; 270 270 break; 271 - case STATE_NEEDS_INIT: 272 - case STATE_IDLE: 271 + case VIDEOBUF_NEEDS_INIT: 272 + case VIDEOBUF_IDLE: 273 273 /* nothing */ 274 274 break; 275 275 } ··· 498 498 dprintk(1,"qbuf: memory type is wrong.\n"); 499 499 goto done; 500 500 } 501 - if (buf->state != STATE_NEEDS_INIT && buf->state != STATE_IDLE) { 501 + if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) { 502 502 dprintk(1,"qbuf: buffer is already queued or active.\n"); 503 503 goto done; 504 504 } ··· 525 525 dprintk(1,"qbuf: buffer length is not enough\n"); 526 526 goto done; 527 527 } 528 - if (STATE_NEEDS_INIT != buf->state && buf->baddr != b->m.userptr) 528 + if (VIDEOBUF_NEEDS_INIT != buf->state && buf->baddr != b->m.userptr) 529 529 q->ops->buf_release(q,buf); 530 530 buf->baddr = b->m.userptr; 531 531 break; ··· 595 595 goto done; 596 596 } 597 597 switch (buf->state) { 598 - case STATE_ERROR: 598 + case VIDEOBUF_ERROR: 599 599 dprintk(1,"dqbuf: state is error\n"); 600 600 retval = -EIO; 601 601 CALL(q,sync,q, buf); 602 - buf->state = STATE_IDLE; 602 + buf->state = VIDEOBUF_IDLE; 603 603 break; 604 - case STATE_DONE: 604 + case VIDEOBUF_DONE: 605 605 dprintk(1,"dqbuf: state is done\n"); 606 606 CALL(q,sync,q, buf); 607 - buf->state = STATE_IDLE; 607 + buf->state = VIDEOBUF_IDLE; 608 608 break; 609 609 default: 610 610 dprintk(1,"dqbuf: state invalid\n"); ··· 637 637 if (q->irqlock) 638 638 spin_lock_irqsave(q->irqlock,flags); 639 639 list_for_each_entry(buf, &q->stream, stream) 640 - if (buf->state == STATE_PREPARED) 640 + if (buf->state == VIDEOBUF_PREPARED) 641 641 q->ops->buf_queue(q,buf); 642 642 if (q->irqlock) 643 643 spin_unlock_irqrestore(q->irqlock,flags); ··· 704 704 retval = videobuf_waiton(q->read_buf,0,0); 705 705 if (0 == retval) { 706 706 CALL(q,sync,q,q->read_buf); 707 - if (STATE_ERROR == q->read_buf->state) 707 + if (VIDEOBUF_ERROR == q->read_buf->state) 708 708 retval = -EIO; 709 709 else 710 710 retval = q->read_buf->size; ··· 778 778 779 779 CALL(q,sync,q,q->read_buf); 780 780 781 - if (STATE_ERROR == q->read_buf->state) { 781 + if (VIDEOBUF_ERROR == q->read_buf->state) { 782 782 /* catch I/O errors */ 783 783 q->ops->buf_release(q,q->read_buf); 784 784 kfree(q->read_buf); ··· 931 931 break; 932 932 } 933 933 934 - if (q->read_buf->state == STATE_DONE) { 934 + if (q->read_buf->state == VIDEOBUF_DONE) { 935 935 rc = CALL (q,copy_stream, q, data + retval, count, 936 936 retval, vbihack, nonblocking); 937 937 if (rc < 0) { ··· 999 999 1000 1000 if (0 == rc) { 1001 1001 poll_wait(file, &buf->done, wait); 1002 - if (buf->state == STATE_DONE || 1003 - buf->state == STATE_ERROR) 1002 + if (buf->state == VIDEOBUF_DONE || 1003 + buf->state == VIDEOBUF_ERROR) 1004 1004 rc = POLLIN|POLLRDNORM; 1005 1005 } 1006 1006 mutex_unlock(&q->lock);
+1 -1
drivers/media/video/videobuf-dvb.c
··· 67 67 68 68 /* feed buffer data to demux */ 69 69 dma=videobuf_to_dma(buf); 70 - if (buf->state == STATE_DONE) 70 + if (buf->state == VIDEOBUF_DONE) 71 71 dvb_dmx_swfilter(&dvb->demux, dma->vmalloc, 72 72 buf->size); 73 73
+12 -12
drivers/media/video/vivi.c
··· 370 370 (unsigned long)tmpbuf,pos); 371 371 372 372 /* Advice that buffer was filled */ 373 - buf->vb.state = STATE_DONE; 373 + buf->vb.state = VIDEOBUF_DONE; 374 374 buf->vb.field_count++; 375 375 do_gettimeofday(&ts); 376 376 buf->vb.ts = ts; ··· 522 522 /* cancel all outstanding capture / vbi requests */ 523 523 list_for_each_entry_safe(buf, prev, &dma_q->active, vb.queue) { 524 524 list_del(&buf->vb.queue); 525 - buf->vb.state = STATE_ERROR; 525 + buf->vb.state = VIDEOBUF_ERROR; 526 526 wake_up(&buf->vb.done); 527 527 } 528 528 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT); ··· 543 543 vivi_stop_thread(dma_q); 544 544 vivi_start_thread(dma_q); 545 545 546 - buf->vb.state = STATE_ACTIVE; 546 + buf->vb.state = VIDEOBUF_ACTIVE; 547 547 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT); 548 548 dprintk(2,"[%p/%d] restart_queue - first active\n", 549 549 buf,buf->vb.i); ··· 553 553 prev->fmt == buf->fmt) { 554 554 list_del(&buf->vb.queue); 555 555 list_add_tail(&buf->vb.queue,&dma_q->active); 556 - buf->vb.state = STATE_ACTIVE; 556 + buf->vb.state = VIDEOBUF_ACTIVE; 557 557 dprintk(2,"[%p/%d] restart_queue - move to active\n", 558 558 buf,buf->vb.i); 559 559 } else { ··· 572 572 while (!list_empty(&vidq->active)) { 573 573 buf = list_entry(vidq->active.next, struct vivi_buffer, vb.queue); 574 574 list_del(&buf->vb.queue); 575 - buf->vb.state = STATE_ERROR; 575 + buf->vb.state = VIDEOBUF_ERROR; 576 576 wake_up(&buf->vb.done); 577 577 printk("vivi/0: [%p/%d] timeout\n", buf, buf->vb.i); 578 578 } ··· 610 610 611 611 videobuf_waiton(&buf->vb,0,0); 612 612 videobuf_vmalloc_free(&buf->vb); 613 - buf->vb.state = STATE_NEEDS_INIT; 613 + buf->vb.state = VIDEOBUF_NEEDS_INIT; 614 614 } 615 615 616 616 #define norm_maxw() 1024 ··· 644 644 init_buffer = 1; 645 645 } 646 646 647 - if (STATE_NEEDS_INIT == buf->vb.state) { 647 + if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 648 648 if (0 != (rc = videobuf_iolock(vq,&buf->vb,NULL))) 649 649 goto fail; 650 650 } 651 651 652 - buf->vb.state = STATE_PREPARED; 652 + buf->vb.state = VIDEOBUF_PREPARED; 653 653 654 654 return 0; 655 655 ··· 670 670 if (!list_empty(&vidq->queued)) { 671 671 dprintk(1,"adding vb queue=0x%08lx\n",(unsigned long)&buf->vb.queue); 672 672 list_add_tail(&buf->vb.queue,&vidq->queued); 673 - buf->vb.state = STATE_QUEUED; 673 + buf->vb.state = VIDEOBUF_QUEUED; 674 674 dprintk(2,"[%p/%d] buffer_queue - append to queued\n", 675 675 buf, buf->vb.i); 676 676 } else if (list_empty(&vidq->active)) { 677 677 list_add_tail(&buf->vb.queue,&vidq->active); 678 678 679 - buf->vb.state = STATE_ACTIVE; 679 + buf->vb.state = VIDEOBUF_ACTIVE; 680 680 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT); 681 681 dprintk(2,"[%p/%d] buffer_queue - first active\n", 682 682 buf, buf->vb.i); ··· 688 688 prev->vb.height == buf->vb.height && 689 689 prev->fmt == buf->fmt) { 690 690 list_add_tail(&buf->vb.queue,&vidq->active); 691 - buf->vb.state = STATE_ACTIVE; 691 + buf->vb.state = VIDEOBUF_ACTIVE; 692 692 dprintk(2,"[%p/%d] buffer_queue - append to active\n", 693 693 buf, buf->vb.i); 694 694 695 695 } else { 696 696 list_add_tail(&buf->vb.queue,&vidq->queued); 697 - buf->vb.state = STATE_QUEUED; 697 + buf->vb.state = VIDEOBUF_QUEUED; 698 698 dprintk(2,"[%p/%d] buffer_queue - first queued\n", 699 699 buf, buf->vb.i); 700 700 }
+7 -7
include/media/videobuf-core.h
··· 56 56 }; 57 57 58 58 enum videobuf_state { 59 - STATE_NEEDS_INIT = 0, 60 - STATE_PREPARED = 1, 61 - STATE_QUEUED = 2, 62 - STATE_ACTIVE = 3, 63 - STATE_DONE = 4, 64 - STATE_ERROR = 5, 65 - STATE_IDLE = 6, 59 + VIDEOBUF_NEEDS_INIT = 0, 60 + VIDEOBUF_PREPARED = 1, 61 + VIDEOBUF_QUEUED = 2, 62 + VIDEOBUF_ACTIVE = 3, 63 + VIDEOBUF_DONE = 4, 64 + VIDEOBUF_ERROR = 5, 65 + VIDEOBUF_IDLE = 6, 66 66 }; 67 67 68 68 struct videobuf_buffer {