?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "[PATCH] paravirt: Add startup infrastructure for paravirtualization"
[pv_ops_mirror.git] / drivers / media / common / saa7146_vbi.c
blob063608462ebe19222923c2a57ae010257eaca55e
1 #include <media/saa7146_vv.h>
2
3 static int vbi_pixel_to_capture = 720 * 2;
4
5 static int vbi_workaround(struct saa7146_dev *dev)
6 {
7 struct saa7146_vv *vv = dev->vv_data;
8
9 u32 *cpu;
10 dma_addr_t dma_addr;
11
12 int count = 0;
13 int i;
14
15 DECLARE_WAITQUEUE(wait, current);
16
17 DEB_VBI(("dev:%p\n",dev));
18
19 /* once again, a bug in the saa7146: the brs acquisition
20 is buggy and especially the BXO-counter does not work
21 as specified. there is this workaround, but please
22 don't let me explain it. ;-) */
23
24 cpu = pci_alloc_consistent(dev->pci, 4096, &dma_addr);
25 if (NULL == cpu)
26 return -ENOMEM;
27
28 /* setup some basic programming, just for the workaround */
29 saa7146_write(dev, BASE_EVEN3, dma_addr);
30 saa7146_write(dev, BASE_ODD3, dma_addr+vbi_pixel_to_capture);
31 saa7146_write(dev, PROT_ADDR3, dma_addr+4096);
32 saa7146_write(dev, PITCH3, vbi_pixel_to_capture);
33 saa7146_write(dev, BASE_PAGE3, 0x0);
34 saa7146_write(dev, NUM_LINE_BYTE3, (2<<16)|((vbi_pixel_to_capture)<<0));
35 saa7146_write(dev, MC2, MASK_04|MASK_20);
36
37 /* load brs-control register */
38 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (BRS_CTRL/4));
39 /* BXO = 1h, BRS to outbound */
40 WRITE_RPS1(0xc000008c);
41 /* wait for vbi_a or vbi_b*/
42 if ( 0 != (SAA7146_USE_PORT_B_FOR_VBI & dev->ext_vv_data->flags)) {
43 DEB_D(("...using port b\n"));
44 WRITE_RPS1(CMD_PAUSE | CMD_OAN | CMD_SIG1 | CMD_E_FID_B);
45 WRITE_RPS1(CMD_PAUSE | CMD_OAN | CMD_SIG1 | CMD_O_FID_B);
46 /*
47 WRITE_RPS1(CMD_PAUSE | MASK_09);
48 */
49 } else {
50 DEB_D(("...using port a\n"));
51 WRITE_RPS1(CMD_PAUSE | MASK_10);
52 }
53 /* upload brs */
54 WRITE_RPS1(CMD_UPLOAD | MASK_08);
55 /* load brs-control register */
56 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (BRS_CTRL/4));
57 /* BYO = 1, BXO = NQBIL (=1728 for PAL, for NTSC this is 858*2) - NumByte3 (=1440) = 288 */
58 WRITE_RPS1(((1728-(vbi_pixel_to_capture)) << 7) | MASK_19);
59 /* wait for brs_done */
60 WRITE_RPS1(CMD_PAUSE | MASK_08);
61 /* upload brs */
62 WRITE_RPS1(CMD_UPLOAD | MASK_08);
63 /* load video-dma3 NumLines3 and NumBytes3 */
64 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (NUM_LINE_BYTE3/4));
65 /* dev->vbi_count*2 lines, 720 pixel (= 1440 Bytes) */
66 WRITE_RPS1((2 << 16) | (vbi_pixel_to_capture));
67 /* load brs-control register */
68 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (BRS_CTRL/4));
69 /* Set BRS right: note: this is an experimental value for BXO (=> PAL!) */
70 WRITE_RPS1((540 << 7) | (5 << 19)); // 5 == vbi_start
71 /* wait for brs_done */
72 WRITE_RPS1(CMD_PAUSE | MASK_08);
73 /* upload brs and video-dma3*/
74 WRITE_RPS1(CMD_UPLOAD | MASK_08 | MASK_04);
75 /* load mc2 register: enable dma3 */
76 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (MC1/4));
77 WRITE_RPS1(MASK_20 | MASK_04);
78 /* generate interrupt */
79 WRITE_RPS1(CMD_INTERRUPT);
80 /* stop rps1 */
81 WRITE_RPS1(CMD_STOP);
82
83 /* we have to do the workaround twice to be sure that
84 everything is ok */
85 for(i = 0; i < 2; i++) {
86
87 /* indicate to the irq handler that we do the workaround */
88 saa7146_write(dev, MC2, MASK_31|MASK_15);
89
90 saa7146_write(dev, NUM_LINE_BYTE3, (1<<16)|(2<<0));
91 saa7146_write(dev, MC2, MASK_04|MASK_20);
92
93 /* enable rps1 irqs */
94 SAA7146_IER_ENABLE(dev,MASK_28);
95
96 /* prepare to wait to be woken up by the irq-handler */
97 add_wait_queue(&vv->vbi_wq, &wait);
98 current->state = TASK_INTERRUPTIBLE;
99
100 /* start rps1 to enable workaround */
101 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
102 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
103
104 schedule();
105
106 DEB_VBI(("brs bug workaround %d/1.\n",i));
107
108 remove_wait_queue(&vv->vbi_wq, &wait);
109 current->state = TASK_RUNNING;
110
111 /* disable rps1 irqs */
112 SAA7146_IER_DISABLE(dev,MASK_28);
113
114 /* stop video-dma3 */
115 saa7146_write(dev, MC1, MASK_20);
116
117 if(signal_pending(current)) {
118
119 DEB_VBI(("aborted (rps:0x%08x).\n",saa7146_read(dev,RPS_ADDR1)));
120
121 /* stop rps1 for sure */
122 saa7146_write(dev, MC1, MASK_29);
123
124 pci_free_consistent(dev->pci, 4096, cpu, dma_addr);
125 return -EINTR;
126 }
127 }
128
129 pci_free_consistent(dev->pci, 4096, cpu, dma_addr);
130 return 0;
131 }
132
133 static void saa7146_set_vbi_capture(struct saa7146_dev *dev, struct saa7146_buf *buf, struct saa7146_buf *next)
134 {
135 struct saa7146_vv *vv = dev->vv_data;
136
137 struct saa7146_video_dma vdma3;
138
139 int count = 0;
140 unsigned long e_wait = vv->current_hps_sync == SAA7146_HPS_SYNC_PORT_A ? CMD_E_FID_A : CMD_E_FID_B;
141 unsigned long o_wait = vv->current_hps_sync == SAA7146_HPS_SYNC_PORT_A ? CMD_O_FID_A : CMD_O_FID_B;
142
143 /*
144 vdma3.base_even = 0xc8000000+2560*70;
145 vdma3.base_odd = 0xc8000000;
146 vdma3.prot_addr = 0xc8000000+2560*164;
147 vdma3.pitch = 2560;
148 vdma3.base_page = 0;
149 vdma3.num_line_byte = (64<<16)|((vbi_pixel_to_capture)<<0); // set above!
150 */
151 vdma3.base_even = buf->pt[2].offset;
152 vdma3.base_odd = buf->pt[2].offset + 16 * vbi_pixel_to_capture;
153 vdma3.prot_addr = buf->pt[2].offset + 16 * 2 * vbi_pixel_to_capture;
154 vdma3.pitch = vbi_pixel_to_capture;
155 vdma3.base_page = buf->pt[2].dma | ME1;
156 vdma3.num_line_byte = (16 << 16) | vbi_pixel_to_capture;
157
158 saa7146_write_out_dma(dev, 3, &vdma3);
159
160 /* write beginning of rps-program */
161 count = 0;
162
163 /* wait for o_fid_a/b / e_fid_a/b toggle only if bit 1 is not set */
164
165 /* we don't wait here for the first field anymore. this is different from the video
166 capture and might cause that the first buffer is only half filled (with only
167 one field). but since this is some sort of streaming data, this is not that negative.
168 but by doing this, we can use the whole engine from video-buf.c... */
169
170 /*
171 WRITE_RPS1(CMD_PAUSE | CMD_OAN | CMD_SIG1 | e_wait);
172 WRITE_RPS1(CMD_PAUSE | CMD_OAN | CMD_SIG1 | o_wait);
173 */
174 /* set bit 1 */
175 WRITE_RPS1(CMD_WR_REG | (1 << 8) | (MC2/4));
176 WRITE_RPS1(MASK_28 | MASK_12);
177
178 /* turn on video-dma3 */
179 WRITE_RPS1(CMD_WR_REG_MASK | (MC1/4));
180 WRITE_RPS1(MASK_04 | MASK_20); /* => mask */
181 WRITE_RPS1(MASK_04 | MASK_20); /* => values */
182
183 /* wait for o_fid_a/b / e_fid_a/b toggle */
184 WRITE_RPS1(CMD_PAUSE | o_wait);
185 WRITE_RPS1(CMD_PAUSE | e_wait);
186
187 /* generate interrupt */
188 WRITE_RPS1(CMD_INTERRUPT);
189
190 /* stop */
191 WRITE_RPS1(CMD_STOP);
192
193 /* enable rps1 irqs */
194 SAA7146_IER_ENABLE(dev, MASK_28);
195
196 /* write the address of the rps-program */
197 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
198
199 /* turn on rps */
200 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
201 }
202
203 static int buffer_activate(struct saa7146_dev *dev,
204 struct saa7146_buf *buf,
205 struct saa7146_buf *next)
206 {
207 struct saa7146_vv *vv = dev->vv_data;
208 buf->vb.state = STATE_ACTIVE;
209
210 DEB_VBI(("dev:%p, buf:%p, next:%p\n",dev,buf,next));
211 saa7146_set_vbi_capture(dev,buf,next);
212
213 mod_timer(&vv->vbi_q.timeout, jiffies+BUFFER_TIMEOUT);
214 return 0;
215 }
216
217 static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,enum v4l2_field field)
218 {
219 struct file *file = q->priv_data;
220 struct saa7146_fh *fh = file->private_data;
221 struct saa7146_dev *dev = fh->dev;
222 struct saa7146_buf *buf = (struct saa7146_buf *)vb;
223
224 int err = 0;
225 int lines, llength, size;
226
227 lines = 16 * 2 ; /* 2 fields */
228 llength = vbi_pixel_to_capture;
229 size = lines * llength;
230
231 DEB_VBI(("vb:%p\n",vb));
232
233 if (0 != buf->vb.baddr && buf->vb.bsize < size) {
234 DEB_VBI(("size mismatch.\n"));
235 return -EINVAL;
236 }
237
238 if (buf->vb.size != size)
239 saa7146_dma_free(dev,q,buf);
240
241 if (STATE_NEEDS_INIT == buf->vb.state) {
242 buf->vb.width = llength;
243 buf->vb.height = lines;
244 buf->vb.size = size;
245 buf->vb.field = field; // FIXME: check this
246
247 saa7146_pgtable_free(dev->pci, &buf->pt[2]);
248 saa7146_pgtable_alloc(dev->pci, &buf->pt[2]);
249
250 err = videobuf_iolock(q,&buf->vb, NULL);
251 if (err)
252 goto oops;
253 err = saa7146_pgtable_build_single(dev->pci, &buf->pt[2], buf->vb.dma.sglist, buf->vb.dma.sglen);
254 if (0 != err)
255 return err;
256 }
257 buf->vb.state = STATE_PREPARED;
258 buf->activate = buffer_activate;
259
260 return 0;
261
262 oops:
263 DEB_VBI(("error out.\n"));
264 saa7146_dma_free(dev,q,buf);
265
266 return err;
267 }
268
269 static int buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
270 {
271 int llength,lines;
272
273 lines = 16 * 2 ; /* 2 fields */
274 llength = vbi_pixel_to_capture;
275
276 *size = lines * llength;
277 *count = 2;
278
279 DEB_VBI(("count:%d, size:%d\n",*count,*size));
280
281 return 0;
282 }
283
284 static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
285 {
286 struct file *file = q->priv_data;
287 struct saa7146_fh *fh = file->private_data;
288 struct saa7146_dev *dev = fh->dev;
289 struct saa7146_vv *vv = dev->vv_data;
290 struct saa7146_buf *buf = (struct saa7146_buf *)vb;
291
292 DEB_VBI(("vb:%p\n",vb));
293 saa7146_buffer_queue(dev,&vv->vbi_q,buf);
294 }
295
296 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
297 {
298 struct file *file = q->priv_data;
299 struct saa7146_fh *fh = file->private_data;
300 struct saa7146_dev *dev = fh->dev;
301 struct saa7146_buf *buf = (struct saa7146_buf *)vb;
302
303 DEB_VBI(("vb:%p\n",vb));
304 saa7146_dma_free(dev,q,buf);
305 }
306
307 static struct videobuf_queue_ops vbi_qops = {
308 .buf_setup = buffer_setup,
309 .buf_prepare = buffer_prepare,
310 .buf_queue = buffer_queue,
311 .buf_release = buffer_release,
312 };
313
314 /* ------------------------------------------------------------------ */
315
316 static void vbi_stop(struct saa7146_fh *fh, struct file *file)
317 {
318 struct saa7146_dev *dev = fh->dev;
319 struct saa7146_vv *vv = dev->vv_data;
320 unsigned long flags;
321 DEB_VBI(("dev:%p, fh:%p\n",dev, fh));
322
323 spin_lock_irqsave(&dev->slock,flags);
324
325 /* disable rps1 */
326 saa7146_write(dev, MC1, MASK_29);
327
328 /* disable rps1 irqs */
329 SAA7146_IER_DISABLE(dev, MASK_28);
330
331 /* shut down dma 3 transfers */
332 saa7146_write(dev, MC1, MASK_20);
333
334 if (vv->vbi_q.curr) {
335 saa7146_buffer_finish(dev,&vv->vbi_q,STATE_DONE);
336 }
337
338 videobuf_queue_cancel(&fh->vbi_q);
339
340 vv->vbi_streaming = NULL;
341
342 del_timer(&vv->vbi_q.timeout);
343 del_timer(&fh->vbi_read_timeout);
344
345 spin_unlock_irqrestore(&dev->slock, flags);
346 }
347
348 static void vbi_read_timeout(unsigned long data)
349 {
350 struct file *file = (struct file*)data;
351 struct saa7146_fh *fh = file->private_data;
352 struct saa7146_dev *dev = fh->dev;
353
354 DEB_VBI(("dev:%p, fh:%p\n",dev, fh));
355
356 vbi_stop(fh, file);
357 }
358
359 static void vbi_init(struct saa7146_dev *dev, struct saa7146_vv *vv)
360 {
361 DEB_VBI(("dev:%p\n",dev));
362
363 INIT_LIST_HEAD(&vv->vbi_q.queue);
364
365 init_timer(&vv->vbi_q.timeout);
366 vv->vbi_q.timeout.function = saa7146_buffer_timeout;
367 vv->vbi_q.timeout.data = (unsigned long)(&vv->vbi_q);
368 vv->vbi_q.dev = dev;
369
370 init_waitqueue_head(&vv->vbi_wq);
371 }
372
373 static int vbi_open(struct saa7146_dev *dev, struct file *file)
374 {
375 struct saa7146_fh *fh = (struct saa7146_fh *)file->private_data;
376
377 u32 arbtr_ctrl = saa7146_read(dev, PCI_BT_V1);
378 int ret = 0;
379
380 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
381
382 ret = saa7146_res_get(fh, RESOURCE_DMA3_BRS);
383 if (0 == ret) {
384 DEB_S(("cannot get vbi RESOURCE_DMA3_BRS resource\n"));
385 return -EBUSY;
386 }
387
388 /* adjust arbitrition control for video dma 3 */
389 arbtr_ctrl &= ~0x1f0000;
390 arbtr_ctrl |= 0x1d0000;
391 saa7146_write(dev, PCI_BT_V1, arbtr_ctrl);
392 saa7146_write(dev, MC2, (MASK_04|MASK_20));
393
394 memset(&fh->vbi_fmt,0,sizeof(fh->vbi_fmt));
395
396 fh->vbi_fmt.sampling_rate = 27000000;
397 fh->vbi_fmt.offset = 248; /* todo */
398 fh->vbi_fmt.samples_per_line = vbi_pixel_to_capture;
399 fh->vbi_fmt.sample_format = V4L2_PIX_FMT_GREY;
400
401 /* fixme: this only works for PAL */
402 fh->vbi_fmt.start[0] = 5;
403 fh->vbi_fmt.count[0] = 16;
404 fh->vbi_fmt.start[1] = 312;
405 fh->vbi_fmt.count[1] = 16;
406
407 videobuf_queue_init(&fh->vbi_q, &vbi_qops,
408 dev->pci, &dev->slock,
409 V4L2_BUF_TYPE_VBI_CAPTURE,
410 V4L2_FIELD_SEQ_TB, // FIXME: does this really work?
411 sizeof(struct saa7146_buf),
412 file);
413 mutex_init(&fh->vbi_q.lock);
414
415 init_timer(&fh->vbi_read_timeout);
416 fh->vbi_read_timeout.function = vbi_read_timeout;
417 fh->vbi_read_timeout.data = (unsigned long)file;
418
419 /* initialize the brs */
420 if ( 0 != (SAA7146_USE_PORT_B_FOR_VBI & dev->ext_vv_data->flags)) {
421 saa7146_write(dev, BRS_CTRL, MASK_30|MASK_29 | (7 << 19));
422 } else {
423 saa7146_write(dev, BRS_CTRL, 0x00000001);
424
425 if (0 != (ret = vbi_workaround(dev))) {
426 DEB_VBI(("vbi workaround failed!\n"));
427 /* return ret;*/
428 }
429 }
430
431 /* upload brs register */
432 saa7146_write(dev, MC2, (MASK_08|MASK_24));
433 return 0;
434 }
435
436 static void vbi_close(struct saa7146_dev *dev, struct file *file)
437 {
438 struct saa7146_fh *fh = (struct saa7146_fh *)file->private_data;
439 struct saa7146_vv *vv = dev->vv_data;
440 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
441
442 if( fh == vv->vbi_streaming ) {
443 vbi_stop(fh, file);
444 }
445 saa7146_res_free(fh, RESOURCE_DMA3_BRS);
446 }
447
448 static void vbi_irq_done(struct saa7146_dev *dev, unsigned long status)
449 {
450 struct saa7146_vv *vv = dev->vv_data;
451 spin_lock(&dev->slock);
452
453 if (vv->vbi_q.curr) {
454 DEB_VBI(("dev:%p, curr:%p\n",dev,vv->vbi_q.curr));
455 /* this must be += 2, one count for each field */
456 vv->vbi_fieldcount+=2;
457 vv->vbi_q.curr->vb.field_count = vv->vbi_fieldcount;
458 saa7146_buffer_finish(dev,&vv->vbi_q,STATE_DONE);
459 } else {
460 DEB_VBI(("dev:%p\n",dev));
461 }
462 saa7146_buffer_next(dev,&vv->vbi_q,1);
463
464 spin_unlock(&dev->slock);
465 }
466
467 static ssize_t vbi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
468 {
469 struct saa7146_fh *fh = file->private_data;
470 struct saa7146_dev *dev = fh->dev;
471 struct saa7146_vv *vv = dev->vv_data;
472 ssize_t ret = 0;
473
474 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
475
476 if( NULL == vv->vbi_streaming ) {
477 // fixme: check if dma3 is available
478 // fixme: activate vbi engine here if necessary. (really?)
479 vv->vbi_streaming = fh;
480 }
481
482 if( fh != vv->vbi_streaming ) {
483 DEB_VBI(("open %p is already using vbi capture.",vv->vbi_streaming));
484 return -EBUSY;
485 }
486
487 mod_timer(&fh->vbi_read_timeout, jiffies+BUFFER_TIMEOUT);
488 ret = videobuf_read_stream(&fh->vbi_q, data, count, ppos, 1,
489 file->f_flags & O_NONBLOCK);
490 /*
491 printk("BASE_ODD3: 0x%08x\n", saa7146_read(dev, BASE_ODD3));
492 printk("BASE_EVEN3: 0x%08x\n", saa7146_read(dev, BASE_EVEN3));
493 printk("PROT_ADDR3: 0x%08x\n", saa7146_read(dev, PROT_ADDR3));
494 printk("PITCH3: 0x%08x\n", saa7146_read(dev, PITCH3));
495 printk("BASE_PAGE3: 0x%08x\n", saa7146_read(dev, BASE_PAGE3));
496 printk("NUM_LINE_BYTE3: 0x%08x\n", saa7146_read(dev, NUM_LINE_BYTE3));
497 printk("BRS_CTRL: 0x%08x\n", saa7146_read(dev, BRS_CTRL));
498 */
499 return ret;
500 }
501
502 struct saa7146_use_ops saa7146_vbi_uops = {
503 .init = vbi_init,
504 .open = vbi_open,
505 .release = vbi_close,
506 .irq_done = vbi_irq_done,
507 .read = vbi_read,
508 };
Mirror for ia64_pv_ops.git