blob: afe85801d6ca8480309db96d77c9215b200dbd63 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#include <media/saa7146_vv.h>
2
3static int vbi_pixel_to_capture = 720 * 2;
4
5static int vbi_workaround(struct saa7146_dev *dev)
6{
7 struct saa7146_vv *vv = dev->vv_data;
8
Mauro Carvalho Chehabafd1a0c2005-12-12 00:37:27 -08009 u32 *cpu;
10 dma_addr_t dma_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
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
133static 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.
Mauro Carvalho Chehabc1accaa2007-08-23 16:37:49 -0300168 but by doing this, we can use the whole engine from videobuf-dma-sg.c... */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
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
203static 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;
Brandon Philips0fc06862007-11-06 20:02:36 -0300208 buf->vb.state = VIDEOBUF_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
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
217static 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)
Mauro Carvalho Chehabc7b0ac02006-03-10 12:29:15 -0300239 saa7146_dma_free(dev,q,buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Brandon Philips0fc06862007-11-06 20:02:36 -0300241 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
Mauro Carvalho Chehabc1accaa2007-08-23 16:37:49 -0300242 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 buf->vb.width = llength;
245 buf->vb.height = lines;
246 buf->vb.size = size;
247 buf->vb.field = field; // FIXME: check this
248
249 saa7146_pgtable_free(dev->pci, &buf->pt[2]);
250 saa7146_pgtable_alloc(dev->pci, &buf->pt[2]);
251
Mauro Carvalho Chehabc7b0ac02006-03-10 12:29:15 -0300252 err = videobuf_iolock(q,&buf->vb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if (err)
254 goto oops;
Mauro Carvalho Chehabc1accaa2007-08-23 16:37:49 -0300255 err = saa7146_pgtable_build_single(dev->pci, &buf->pt[2],
256 dma->sglist, dma->sglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 if (0 != err)
258 return err;
259 }
Brandon Philips0fc06862007-11-06 20:02:36 -0300260 buf->vb.state = VIDEOBUF_PREPARED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 buf->activate = buffer_activate;
262
263 return 0;
264
265 oops:
266 DEB_VBI(("error out.\n"));
Mauro Carvalho Chehabc7b0ac02006-03-10 12:29:15 -0300267 saa7146_dma_free(dev,q,buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 return err;
270}
271
272static int buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
273{
274 int llength,lines;
275
276 lines = 16 * 2 ; /* 2 fields */
277 llength = vbi_pixel_to_capture;
278
279 *size = lines * llength;
280 *count = 2;
281
282 DEB_VBI(("count:%d, size:%d\n",*count,*size));
283
284 return 0;
285}
286
287static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
288{
289 struct file *file = q->priv_data;
290 struct saa7146_fh *fh = file->private_data;
291 struct saa7146_dev *dev = fh->dev;
292 struct saa7146_vv *vv = dev->vv_data;
293 struct saa7146_buf *buf = (struct saa7146_buf *)vb;
294
295 DEB_VBI(("vb:%p\n",vb));
296 saa7146_buffer_queue(dev,&vv->vbi_q,buf);
297}
298
299static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
300{
301 struct file *file = q->priv_data;
302 struct saa7146_fh *fh = file->private_data;
303 struct saa7146_dev *dev = fh->dev;
304 struct saa7146_buf *buf = (struct saa7146_buf *)vb;
305
306 DEB_VBI(("vb:%p\n",vb));
Mauro Carvalho Chehabc7b0ac02006-03-10 12:29:15 -0300307 saa7146_dma_free(dev,q,buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
310static struct videobuf_queue_ops vbi_qops = {
311 .buf_setup = buffer_setup,
312 .buf_prepare = buffer_prepare,
313 .buf_queue = buffer_queue,
314 .buf_release = buffer_release,
315};
316
317/* ------------------------------------------------------------------ */
318
319static void vbi_stop(struct saa7146_fh *fh, struct file *file)
320{
321 struct saa7146_dev *dev = fh->dev;
322 struct saa7146_vv *vv = dev->vv_data;
323 unsigned long flags;
324 DEB_VBI(("dev:%p, fh:%p\n",dev, fh));
325
326 spin_lock_irqsave(&dev->slock,flags);
327
328 /* disable rps1 */
329 saa7146_write(dev, MC1, MASK_29);
330
331 /* disable rps1 irqs */
332 SAA7146_IER_DISABLE(dev, MASK_28);
333
334 /* shut down dma 3 transfers */
335 saa7146_write(dev, MC1, MASK_20);
336
337 if (vv->vbi_q.curr) {
Brandon Philips0fc06862007-11-06 20:02:36 -0300338 saa7146_buffer_finish(dev,&vv->vbi_q,VIDEOBUF_DONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
340
341 videobuf_queue_cancel(&fh->vbi_q);
342
343 vv->vbi_streaming = NULL;
344
345 del_timer(&vv->vbi_q.timeout);
346 del_timer(&fh->vbi_read_timeout);
347
348 spin_unlock_irqrestore(&dev->slock, flags);
349}
350
351static void vbi_read_timeout(unsigned long data)
352{
353 struct file *file = (struct file*)data;
354 struct saa7146_fh *fh = file->private_data;
355 struct saa7146_dev *dev = fh->dev;
356
357 DEB_VBI(("dev:%p, fh:%p\n",dev, fh));
358
359 vbi_stop(fh, file);
360}
361
362static void vbi_init(struct saa7146_dev *dev, struct saa7146_vv *vv)
363{
364 DEB_VBI(("dev:%p\n",dev));
365
366 INIT_LIST_HEAD(&vv->vbi_q.queue);
367
368 init_timer(&vv->vbi_q.timeout);
369 vv->vbi_q.timeout.function = saa7146_buffer_timeout;
370 vv->vbi_q.timeout.data = (unsigned long)(&vv->vbi_q);
371 vv->vbi_q.dev = dev;
372
373 init_waitqueue_head(&vv->vbi_wq);
374}
375
376static int vbi_open(struct saa7146_dev *dev, struct file *file)
377{
Joe Perchesabf84382010-07-12 17:50:03 -0300378 struct saa7146_fh *fh = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
380 u32 arbtr_ctrl = saa7146_read(dev, PCI_BT_V1);
381 int ret = 0;
382
383 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
384
385 ret = saa7146_res_get(fh, RESOURCE_DMA3_BRS);
386 if (0 == ret) {
387 DEB_S(("cannot get vbi RESOURCE_DMA3_BRS resource\n"));
388 return -EBUSY;
389 }
390
391 /* adjust arbitrition control for video dma 3 */
392 arbtr_ctrl &= ~0x1f0000;
393 arbtr_ctrl |= 0x1d0000;
394 saa7146_write(dev, PCI_BT_V1, arbtr_ctrl);
395 saa7146_write(dev, MC2, (MASK_04|MASK_20));
396
397 memset(&fh->vbi_fmt,0,sizeof(fh->vbi_fmt));
398
399 fh->vbi_fmt.sampling_rate = 27000000;
400 fh->vbi_fmt.offset = 248; /* todo */
401 fh->vbi_fmt.samples_per_line = vbi_pixel_to_capture;
402 fh->vbi_fmt.sample_format = V4L2_PIX_FMT_GREY;
403
404 /* fixme: this only works for PAL */
405 fh->vbi_fmt.start[0] = 5;
406 fh->vbi_fmt.count[0] = 16;
407 fh->vbi_fmt.start[1] = 312;
408 fh->vbi_fmt.count[1] = 16;
409
Guennadi Liakhovetski07051352008-04-22 14:42:13 -0300410 videobuf_queue_sg_init(&fh->vbi_q, &vbi_qops,
411 &dev->pci->dev, &dev->slock,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 V4L2_BUF_TYPE_VBI_CAPTURE,
413 V4L2_FIELD_SEQ_TB, // FIXME: does this really work?
414 sizeof(struct saa7146_buf),
Hans Verkuil9af39712010-12-18 09:20:59 -0300415 file, &dev->v4l2_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 init_timer(&fh->vbi_read_timeout);
418 fh->vbi_read_timeout.function = vbi_read_timeout;
419 fh->vbi_read_timeout.data = (unsigned long)file;
420
421 /* initialize the brs */
422 if ( 0 != (SAA7146_USE_PORT_B_FOR_VBI & dev->ext_vv_data->flags)) {
423 saa7146_write(dev, BRS_CTRL, MASK_30|MASK_29 | (7 << 19));
424 } else {
425 saa7146_write(dev, BRS_CTRL, 0x00000001);
426
427 if (0 != (ret = vbi_workaround(dev))) {
428 DEB_VBI(("vbi workaround failed!\n"));
429 /* return ret;*/
430 }
431 }
432
433 /* upload brs register */
434 saa7146_write(dev, MC2, (MASK_08|MASK_24));
435 return 0;
436}
437
438static void vbi_close(struct saa7146_dev *dev, struct file *file)
439{
Joe Perchesabf84382010-07-12 17:50:03 -0300440 struct saa7146_fh *fh = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 struct saa7146_vv *vv = dev->vv_data;
442 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
443
444 if( fh == vv->vbi_streaming ) {
445 vbi_stop(fh, file);
446 }
447 saa7146_res_free(fh, RESOURCE_DMA3_BRS);
448}
449
450static void vbi_irq_done(struct saa7146_dev *dev, unsigned long status)
451{
452 struct saa7146_vv *vv = dev->vv_data;
453 spin_lock(&dev->slock);
454
455 if (vv->vbi_q.curr) {
456 DEB_VBI(("dev:%p, curr:%p\n",dev,vv->vbi_q.curr));
457 /* this must be += 2, one count for each field */
458 vv->vbi_fieldcount+=2;
459 vv->vbi_q.curr->vb.field_count = vv->vbi_fieldcount;
Brandon Philips0fc06862007-11-06 20:02:36 -0300460 saa7146_buffer_finish(dev,&vv->vbi_q,VIDEOBUF_DONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 } else {
462 DEB_VBI(("dev:%p\n",dev));
463 }
464 saa7146_buffer_next(dev,&vv->vbi_q,1);
465
466 spin_unlock(&dev->slock);
467}
468
469static ssize_t vbi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
470{
471 struct saa7146_fh *fh = file->private_data;
472 struct saa7146_dev *dev = fh->dev;
473 struct saa7146_vv *vv = dev->vv_data;
474 ssize_t ret = 0;
475
476 DEB_VBI(("dev:%p, fh:%p\n",dev,fh));
477
478 if( NULL == vv->vbi_streaming ) {
479 // fixme: check if dma3 is available
480 // fixme: activate vbi engine here if necessary. (really?)
481 vv->vbi_streaming = fh;
482 }
483
484 if( fh != vv->vbi_streaming ) {
485 DEB_VBI(("open %p is already using vbi capture.",vv->vbi_streaming));
486 return -EBUSY;
487 }
488
489 mod_timer(&fh->vbi_read_timeout, jiffies+BUFFER_TIMEOUT);
490 ret = videobuf_read_stream(&fh->vbi_q, data, count, ppos, 1,
491 file->f_flags & O_NONBLOCK);
492/*
493 printk("BASE_ODD3: 0x%08x\n", saa7146_read(dev, BASE_ODD3));
494 printk("BASE_EVEN3: 0x%08x\n", saa7146_read(dev, BASE_EVEN3));
495 printk("PROT_ADDR3: 0x%08x\n", saa7146_read(dev, PROT_ADDR3));
496 printk("PITCH3: 0x%08x\n", saa7146_read(dev, PITCH3));
497 printk("BASE_PAGE3: 0x%08x\n", saa7146_read(dev, BASE_PAGE3));
498 printk("NUM_LINE_BYTE3: 0x%08x\n", saa7146_read(dev, NUM_LINE_BYTE3));
499 printk("BRS_CTRL: 0x%08x\n", saa7146_read(dev, BRS_CTRL));
500*/
501 return ret;
502}
503
504struct saa7146_use_ops saa7146_vbi_uops = {
Michael Krufky50c25ff2006-01-09 15:25:34 -0200505 .init = vbi_init,
506 .open = vbi_open,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 .release = vbi_close,
508 .irq_done = vbi_irq_done,
Michael Krufky50c25ff2006-01-09 15:25:34 -0200509 .read = vbi_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510};