1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Driver for the NXP SAA7164 PCIe bridge
4  *
5  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
6  */
7 
8 #include "saa7164.h"
9 
10 /* Take the encoder configuration from the port struct and
11  * flush it to the hardware.
12  */
13 static void saa7164_vbi_configure(struct saa7164_port *port)
14 {
15 	struct saa7164_dev *dev = port->dev;
16 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
17 
18 	port->vbi_params.width = port->enc_port->width;
19 	port->vbi_params.height = port->enc_port->height;
20 	port->vbi_params.is_50hz =
21 		(port->enc_port->encodernorm.id & V4L2_STD_625_50) != 0;
22 
23 	/* Set up the DIF (enable it) for analog mode by default */
24 	saa7164_api_initialize_dif(port);
25 	dprintk(DBGLVL_VBI, "%s() ends\n", __func__);
26 }
27 
28 static int saa7164_vbi_buffers_dealloc(struct saa7164_port *port)
29 {
30 	struct list_head *c, *n, *p, *q, *l, *v;
31 	struct saa7164_dev *dev = port->dev;
32 	struct saa7164_buffer *buf;
33 	struct saa7164_user_buffer *ubuf;
34 
35 	/* Remove any allocated buffers */
36 	mutex_lock(&port->dmaqueue_lock);
37 
38 	dprintk(DBGLVL_VBI, "%s(port=%d) dmaqueue\n", __func__, port->nr);
39 	list_for_each_safe(c, n, &port->dmaqueue.list) {
40 		buf = list_entry(c, struct saa7164_buffer, list);
41 		list_del(c);
42 		saa7164_buffer_dealloc(buf);
43 	}
44 
45 	dprintk(DBGLVL_VBI, "%s(port=%d) used\n", __func__, port->nr);
46 	list_for_each_safe(p, q, &port->list_buf_used.list) {
47 		ubuf = list_entry(p, struct saa7164_user_buffer, list);
48 		list_del(p);
49 		saa7164_buffer_dealloc_user(ubuf);
50 	}
51 
52 	dprintk(DBGLVL_VBI, "%s(port=%d) free\n", __func__, port->nr);
53 	list_for_each_safe(l, v, &port->list_buf_free.list) {
54 		ubuf = list_entry(l, struct saa7164_user_buffer, list);
55 		list_del(l);
56 		saa7164_buffer_dealloc_user(ubuf);
57 	}
58 
59 	mutex_unlock(&port->dmaqueue_lock);
60 	dprintk(DBGLVL_VBI, "%s(port=%d) done\n", __func__, port->nr);
61 
62 	return 0;
63 }
64 
65 /* Dynamic buffer switch at vbi start time */
66 static int saa7164_vbi_buffers_alloc(struct saa7164_port *port)
67 {
68 	struct saa7164_dev *dev = port->dev;
69 	struct saa7164_buffer *buf;
70 	struct saa7164_user_buffer *ubuf;
71 	struct tmHWStreamParameters *params = &port->hw_streamingparams;
72 	int result = -ENODEV, i;
73 	int len = 0;
74 
75 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
76 
77 	/* TODO: NTSC SPECIFIC */
78 	/* Init and establish defaults */
79 	params->samplesperline = 1440;
80 	params->numberoflines = 12;
81 	params->numberoflines = 18;
82 	params->pitch = 1600;
83 	params->pitch = 1440;
84 	params->numpagetables = 2 +
85 		((params->numberoflines * params->pitch) / PAGE_SIZE);
86 	params->bitspersample = 8;
87 	params->linethreshold = 0;
88 	params->pagetablelistvirt = NULL;
89 	params->pagetablelistphys = NULL;
90 	params->numpagetableentries = port->hwcfg.buffercount;
91 
92 	/* Allocate the PCI resources, buffers (hard) */
93 	for (i = 0; i < port->hwcfg.buffercount; i++) {
94 		buf = saa7164_buffer_alloc(port,
95 			params->numberoflines *
96 			params->pitch);
97 
98 		if (!buf) {
99 			printk(KERN_ERR "%s() failed (errno = %d), unable to allocate buffer\n",
100 				__func__, result);
101 			result = -ENOMEM;
102 			goto failed;
103 		} else {
104 
105 			mutex_lock(&port->dmaqueue_lock);
106 			list_add_tail(&buf->list, &port->dmaqueue.list);
107 			mutex_unlock(&port->dmaqueue_lock);
108 
109 		}
110 	}
111 
112 	/* Allocate some kernel buffers for copying
113 	 * to userpsace.
114 	 */
115 	len = params->numberoflines * params->pitch;
116 
117 	if (vbi_buffers < 16)
118 		vbi_buffers = 16;
119 	if (vbi_buffers > 512)
120 		vbi_buffers = 512;
121 
122 	for (i = 0; i < vbi_buffers; i++) {
123 
124 		ubuf = saa7164_buffer_alloc_user(dev, len);
125 		if (ubuf) {
126 			mutex_lock(&port->dmaqueue_lock);
127 			list_add_tail(&ubuf->list, &port->list_buf_free.list);
128 			mutex_unlock(&port->dmaqueue_lock);
129 		}
130 
131 	}
132 
133 	result = 0;
134 
135 failed:
136 	return result;
137 }
138 
139 
140 static int saa7164_vbi_initialize(struct saa7164_port *port)
141 {
142 	saa7164_vbi_configure(port);
143 	return 0;
144 }
145 
146 /* -- V4L2 --------------------------------------------------------- */
147 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
148 {
149 	struct saa7164_vbi_fh *fh = file->private_data;
150 
151 	return saa7164_s_std(fh->port->enc_port, id);
152 }
153 
154 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
155 {
156 	struct saa7164_encoder_fh *fh = file->private_data;
157 
158 	return saa7164_g_std(fh->port->enc_port, id);
159 }
160 
161 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
162 {
163 	struct saa7164_vbi_fh *fh = file->private_data;
164 
165 	return saa7164_g_input(fh->port->enc_port, i);
166 }
167 
168 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
169 {
170 	struct saa7164_vbi_fh *fh = file->private_data;
171 
172 	return saa7164_s_input(fh->port->enc_port, i);
173 }
174 
175 static int vidioc_g_frequency(struct file *file, void *priv,
176 	struct v4l2_frequency *f)
177 {
178 	struct saa7164_vbi_fh *fh = file->private_data;
179 
180 	return saa7164_g_frequency(fh->port->enc_port, f);
181 }
182 
183 static int vidioc_s_frequency(struct file *file, void *priv,
184 	const struct v4l2_frequency *f)
185 {
186 	struct saa7164_vbi_fh *fh = file->private_data;
187 	int ret = saa7164_s_frequency(fh->port->enc_port, f);
188 
189 	if (ret == 0)
190 		saa7164_vbi_initialize(fh->port);
191 	return ret;
192 }
193 
194 static int vidioc_querycap(struct file *file, void  *priv,
195 	struct v4l2_capability *cap)
196 {
197 	struct saa7164_vbi_fh *fh = file->private_data;
198 	struct saa7164_port *port = fh->port;
199 	struct saa7164_dev *dev = port->dev;
200 
201 	strscpy(cap->driver, dev->name, sizeof(cap->driver));
202 	strscpy(cap->card, saa7164_boards[dev->board].name,
203 		sizeof(cap->card));
204 	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
205 	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
206 			    V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE |
207 			    V4L2_CAP_DEVICE_CAPS;
208 	return 0;
209 }
210 
211 static int saa7164_vbi_stop_port(struct saa7164_port *port)
212 {
213 	struct saa7164_dev *dev = port->dev;
214 	int ret;
215 
216 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
217 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
218 		printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
219 			__func__, ret);
220 		ret = -EIO;
221 	} else {
222 		dprintk(DBGLVL_VBI, "%s()    Stopped\n", __func__);
223 		ret = 0;
224 	}
225 
226 	return ret;
227 }
228 
229 static int saa7164_vbi_acquire_port(struct saa7164_port *port)
230 {
231 	struct saa7164_dev *dev = port->dev;
232 	int ret;
233 
234 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
235 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
236 		printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
237 			__func__, ret);
238 		ret = -EIO;
239 	} else {
240 		dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__);
241 		ret = 0;
242 	}
243 
244 	return ret;
245 }
246 
247 static int saa7164_vbi_pause_port(struct saa7164_port *port)
248 {
249 	struct saa7164_dev *dev = port->dev;
250 	int ret;
251 
252 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
253 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
254 		printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
255 			__func__, ret);
256 		ret = -EIO;
257 	} else {
258 		dprintk(DBGLVL_VBI, "%s()   Paused\n", __func__);
259 		ret = 0;
260 	}
261 
262 	return ret;
263 }
264 
265 /* Firmware is very windows centric, meaning you have to transition
266  * the part through AVStream / KS Windows stages, forwards or backwards.
267  * States are: stopped, acquired (h/w), paused, started.
268  * We have to leave here will all of the soft buffers on the free list,
269  * else the cfg_post() func won't have soft buffers to correctly configure.
270  */
271 static int saa7164_vbi_stop_streaming(struct saa7164_port *port)
272 {
273 	struct saa7164_dev *dev = port->dev;
274 	struct saa7164_buffer *buf;
275 	struct saa7164_user_buffer *ubuf;
276 	struct list_head *c, *n;
277 	int ret;
278 
279 	dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
280 
281 	ret = saa7164_vbi_pause_port(port);
282 	ret = saa7164_vbi_acquire_port(port);
283 	ret = saa7164_vbi_stop_port(port);
284 
285 	dprintk(DBGLVL_VBI, "%s(port=%d) Hardware stopped\n", __func__,
286 		port->nr);
287 
288 	/* Reset the state of any allocated buffer resources */
289 	mutex_lock(&port->dmaqueue_lock);
290 
291 	/* Reset the hard and soft buffer state */
292 	list_for_each_safe(c, n, &port->dmaqueue.list) {
293 		buf = list_entry(c, struct saa7164_buffer, list);
294 		buf->flags = SAA7164_BUFFER_FREE;
295 		buf->pos = 0;
296 	}
297 
298 	list_for_each_safe(c, n, &port->list_buf_used.list) {
299 		ubuf = list_entry(c, struct saa7164_user_buffer, list);
300 		ubuf->pos = 0;
301 		list_move_tail(&ubuf->list, &port->list_buf_free.list);
302 	}
303 
304 	mutex_unlock(&port->dmaqueue_lock);
305 
306 	/* Free any allocated resources */
307 	saa7164_vbi_buffers_dealloc(port);
308 
309 	dprintk(DBGLVL_VBI, "%s(port=%d) Released\n", __func__, port->nr);
310 
311 	return ret;
312 }
313 
314 static int saa7164_vbi_start_streaming(struct saa7164_port *port)
315 {
316 	struct saa7164_dev *dev = port->dev;
317 	int result, ret = 0;
318 
319 	dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
320 
321 	port->done_first_interrupt = 0;
322 
323 	/* allocate all of the PCIe DMA buffer resources on the fly,
324 	 * allowing switching between TS and PS payloads without
325 	 * requiring a complete driver reload.
326 	 */
327 	saa7164_vbi_buffers_alloc(port);
328 
329 	/* Configure the encoder with any cache values */
330 #if 0
331 	saa7164_api_set_encoder(port);
332 	saa7164_api_get_encoder(port);
333 #endif
334 
335 	/* Place the empty buffers on the hardware */
336 	saa7164_buffer_cfg_port(port);
337 
338 	/* Negotiate format */
339 	if (saa7164_api_set_vbi_format(port) != SAA_OK) {
340 		printk(KERN_ERR "%s() No supported VBI format\n", __func__);
341 		ret = -EIO;
342 		goto out;
343 	}
344 
345 	/* Acquire the hardware */
346 	result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
347 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
348 		printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
349 			__func__, result);
350 
351 		ret = -EIO;
352 		goto out;
353 	} else
354 		dprintk(DBGLVL_VBI, "%s()   Acquired\n", __func__);
355 
356 	/* Pause the hardware */
357 	result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
358 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
359 		printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
360 				__func__, result);
361 
362 		/* Stop the hardware, regardless */
363 		result = saa7164_vbi_stop_port(port);
364 		if (result != SAA_OK) {
365 			printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
366 			       __func__, result);
367 		}
368 
369 		ret = -EIO;
370 		goto out;
371 	} else
372 		dprintk(DBGLVL_VBI, "%s()   Paused\n", __func__);
373 
374 	/* Start the hardware */
375 	result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
376 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
377 		printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
378 				__func__, result);
379 
380 		/* Stop the hardware, regardless */
381 		result = saa7164_vbi_acquire_port(port);
382 		result = saa7164_vbi_stop_port(port);
383 		if (result != SAA_OK) {
384 			printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
385 			       __func__, result);
386 		}
387 
388 		ret = -EIO;
389 	} else
390 		dprintk(DBGLVL_VBI, "%s()   Running\n", __func__);
391 
392 out:
393 	return ret;
394 }
395 
396 static int saa7164_vbi_fmt(struct file *file, void *priv,
397 			   struct v4l2_format *f)
398 {
399 	/* ntsc */
400 	f->fmt.vbi.samples_per_line = 1440;
401 	f->fmt.vbi.sampling_rate = 27000000;
402 	f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
403 	f->fmt.vbi.offset = 0;
404 	f->fmt.vbi.flags = 0;
405 	f->fmt.vbi.start[0] = 10;
406 	f->fmt.vbi.count[0] = 18;
407 	f->fmt.vbi.start[1] = 263 + 10 + 1;
408 	f->fmt.vbi.count[1] = 18;
409 	memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
410 	return 0;
411 }
412 
413 static int fops_open(struct file *file)
414 {
415 	struct saa7164_dev *dev;
416 	struct saa7164_port *port;
417 	struct saa7164_vbi_fh *fh;
418 
419 	port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
420 	if (!port)
421 		return -ENODEV;
422 
423 	dev = port->dev;
424 
425 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
426 
427 	/* allocate + initialize per filehandle data */
428 	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
429 	if (NULL == fh)
430 		return -ENOMEM;
431 
432 	fh->port = port;
433 	v4l2_fh_init(&fh->fh, video_devdata(file));
434 	v4l2_fh_add(&fh->fh);
435 	file->private_data = fh;
436 
437 	return 0;
438 }
439 
440 static int fops_release(struct file *file)
441 {
442 	struct saa7164_vbi_fh *fh = file->private_data;
443 	struct saa7164_port *port = fh->port;
444 	struct saa7164_dev *dev = port->dev;
445 
446 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
447 
448 	/* Shut device down on last close */
449 	if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
450 		if (atomic_dec_return(&port->v4l_reader_count) == 0) {
451 			/* stop vbi capture then cancel buffers */
452 			saa7164_vbi_stop_streaming(port);
453 		}
454 	}
455 
456 	v4l2_fh_del(&fh->fh);
457 	v4l2_fh_exit(&fh->fh);
458 	kfree(fh);
459 
460 	return 0;
461 }
462 
463 static struct
464 saa7164_user_buffer *saa7164_vbi_next_buf(struct saa7164_port *port)
465 {
466 	struct saa7164_user_buffer *ubuf = NULL;
467 	struct saa7164_dev *dev = port->dev;
468 	u32 crc;
469 
470 	mutex_lock(&port->dmaqueue_lock);
471 	if (!list_empty(&port->list_buf_used.list)) {
472 		ubuf = list_first_entry(&port->list_buf_used.list,
473 			struct saa7164_user_buffer, list);
474 
475 		if (crc_checking) {
476 			crc = crc32(0, ubuf->data, ubuf->actual_size);
477 			if (crc != ubuf->crc) {
478 				printk(KERN_ERR "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
479 					__func__,
480 					ubuf, ubuf->crc, crc);
481 			}
482 		}
483 
484 	}
485 	mutex_unlock(&port->dmaqueue_lock);
486 
487 	dprintk(DBGLVL_VBI, "%s() returns %p\n", __func__, ubuf);
488 
489 	return ubuf;
490 }
491 
492 static ssize_t fops_read(struct file *file, char __user *buffer,
493 	size_t count, loff_t *pos)
494 {
495 	struct saa7164_vbi_fh *fh = file->private_data;
496 	struct saa7164_port *port = fh->port;
497 	struct saa7164_user_buffer *ubuf = NULL;
498 	struct saa7164_dev *dev = port->dev;
499 	int ret = 0;
500 	int rem, cnt;
501 	u8 *p;
502 
503 	port->last_read_msecs_diff = port->last_read_msecs;
504 	port->last_read_msecs = jiffies_to_msecs(jiffies);
505 	port->last_read_msecs_diff = port->last_read_msecs -
506 		port->last_read_msecs_diff;
507 
508 	saa7164_histogram_update(&port->read_interval,
509 		port->last_read_msecs_diff);
510 
511 	if (*pos) {
512 		printk(KERN_ERR "%s() ESPIPE\n", __func__);
513 		return -ESPIPE;
514 	}
515 
516 	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
517 		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
518 
519 			if (saa7164_vbi_initialize(port) < 0) {
520 				printk(KERN_ERR "%s() EINVAL\n", __func__);
521 				return -EINVAL;
522 			}
523 
524 			saa7164_vbi_start_streaming(port);
525 			msleep(200);
526 		}
527 	}
528 
529 	/* blocking wait for buffer */
530 	if ((file->f_flags & O_NONBLOCK) == 0) {
531 		if (wait_event_interruptible(port->wait_read,
532 			saa7164_vbi_next_buf(port))) {
533 				printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
534 				return -ERESTARTSYS;
535 		}
536 	}
537 
538 	/* Pull the first buffer from the used list */
539 	ubuf = saa7164_vbi_next_buf(port);
540 
541 	while ((count > 0) && ubuf) {
542 
543 		/* set remaining bytes to copy */
544 		rem = ubuf->actual_size - ubuf->pos;
545 		cnt = rem > count ? count : rem;
546 
547 		p = ubuf->data + ubuf->pos;
548 
549 		dprintk(DBGLVL_VBI,
550 			"%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
551 			__func__, (int)count, cnt, rem, ubuf, ubuf->pos);
552 
553 		if (copy_to_user(buffer, p, cnt)) {
554 			printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
555 			if (!ret) {
556 				printk(KERN_ERR "%s() EFAULT\n", __func__);
557 				ret = -EFAULT;
558 			}
559 			goto err;
560 		}
561 
562 		ubuf->pos += cnt;
563 		count -= cnt;
564 		buffer += cnt;
565 		ret += cnt;
566 
567 		if (ubuf->pos > ubuf->actual_size)
568 			printk(KERN_ERR "read() pos > actual, huh?\n");
569 
570 		if (ubuf->pos == ubuf->actual_size) {
571 
572 			/* finished with current buffer, take next buffer */
573 
574 			/* Requeue the buffer on the free list */
575 			ubuf->pos = 0;
576 
577 			mutex_lock(&port->dmaqueue_lock);
578 			list_move_tail(&ubuf->list, &port->list_buf_free.list);
579 			mutex_unlock(&port->dmaqueue_lock);
580 
581 			/* Dequeue next */
582 			if ((file->f_flags & O_NONBLOCK) == 0) {
583 				if (wait_event_interruptible(port->wait_read,
584 					saa7164_vbi_next_buf(port))) {
585 						break;
586 				}
587 			}
588 			ubuf = saa7164_vbi_next_buf(port);
589 		}
590 	}
591 err:
592 	if (!ret && !ubuf) {
593 		printk(KERN_ERR "%s() EAGAIN\n", __func__);
594 		ret = -EAGAIN;
595 	}
596 
597 	return ret;
598 }
599 
600 static __poll_t fops_poll(struct file *file, poll_table *wait)
601 {
602 	struct saa7164_vbi_fh *fh = (struct saa7164_vbi_fh *)file->private_data;
603 	struct saa7164_port *port = fh->port;
604 	__poll_t mask = 0;
605 
606 	port->last_poll_msecs_diff = port->last_poll_msecs;
607 	port->last_poll_msecs = jiffies_to_msecs(jiffies);
608 	port->last_poll_msecs_diff = port->last_poll_msecs -
609 		port->last_poll_msecs_diff;
610 
611 	saa7164_histogram_update(&port->poll_interval,
612 		port->last_poll_msecs_diff);
613 
614 	if (!video_is_registered(port->v4l_device))
615 		return EPOLLERR;
616 
617 	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
618 		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
619 			if (saa7164_vbi_initialize(port) < 0)
620 				return EPOLLERR;
621 			saa7164_vbi_start_streaming(port);
622 			msleep(200);
623 		}
624 	}
625 
626 	/* blocking wait for buffer */
627 	if ((file->f_flags & O_NONBLOCK) == 0) {
628 		if (wait_event_interruptible(port->wait_read,
629 			saa7164_vbi_next_buf(port))) {
630 				return EPOLLERR;
631 		}
632 	}
633 
634 	/* Pull the first buffer from the used list */
635 	if (!list_empty(&port->list_buf_used.list))
636 		mask |= EPOLLIN | EPOLLRDNORM;
637 
638 	return mask;
639 }
640 static const struct v4l2_file_operations vbi_fops = {
641 	.owner		= THIS_MODULE,
642 	.open		= fops_open,
643 	.release	= fops_release,
644 	.read		= fops_read,
645 	.poll		= fops_poll,
646 	.unlocked_ioctl	= video_ioctl2,
647 };
648 
649 static const struct v4l2_ioctl_ops vbi_ioctl_ops = {
650 	.vidioc_s_std		 = vidioc_s_std,
651 	.vidioc_g_std		 = vidioc_g_std,
652 	.vidioc_enum_input	 = saa7164_enum_input,
653 	.vidioc_g_input		 = vidioc_g_input,
654 	.vidioc_s_input		 = vidioc_s_input,
655 	.vidioc_g_tuner		 = saa7164_g_tuner,
656 	.vidioc_s_tuner		 = saa7164_s_tuner,
657 	.vidioc_g_frequency	 = vidioc_g_frequency,
658 	.vidioc_s_frequency	 = vidioc_s_frequency,
659 	.vidioc_querycap	 = vidioc_querycap,
660 	.vidioc_g_fmt_vbi_cap	 = saa7164_vbi_fmt,
661 	.vidioc_try_fmt_vbi_cap	 = saa7164_vbi_fmt,
662 	.vidioc_s_fmt_vbi_cap	 = saa7164_vbi_fmt,
663 };
664 
665 static struct video_device saa7164_vbi_template = {
666 	.name          = "saa7164",
667 	.fops          = &vbi_fops,
668 	.ioctl_ops     = &vbi_ioctl_ops,
669 	.minor         = -1,
670 	.tvnorms       = SAA7164_NORMS,
671 	.device_caps   = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE |
672 			 V4L2_CAP_TUNER,
673 };
674 
675 static struct video_device *saa7164_vbi_alloc(
676 	struct saa7164_port *port,
677 	struct pci_dev *pci,
678 	struct video_device *template,
679 	char *type)
680 {
681 	struct video_device *vfd;
682 	struct saa7164_dev *dev = port->dev;
683 
684 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
685 
686 	vfd = video_device_alloc();
687 	if (NULL == vfd)
688 		return NULL;
689 
690 	*vfd = *template;
691 	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
692 		type, saa7164_boards[dev->board].name);
693 
694 	vfd->v4l2_dev  = &dev->v4l2_dev;
695 	vfd->release = video_device_release;
696 	return vfd;
697 }
698 
699 int saa7164_vbi_register(struct saa7164_port *port)
700 {
701 	struct saa7164_dev *dev = port->dev;
702 	int result = -ENODEV;
703 
704 	dprintk(DBGLVL_VBI, "%s()\n", __func__);
705 
706 	if (port->type != SAA7164_MPEG_VBI)
707 		BUG();
708 
709 	/* Sanity check that the PCI configuration space is active */
710 	if (port->hwcfg.BARLocation == 0) {
711 		printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n",
712 			__func__, result);
713 		result = -ENOMEM;
714 		goto failed;
715 	}
716 
717 	/* Establish VBI defaults here */
718 
719 	/* Allocate and register the video device node */
720 	port->v4l_device = saa7164_vbi_alloc(port,
721 		dev->pci, &saa7164_vbi_template, "vbi");
722 
723 	if (!port->v4l_device) {
724 		printk(KERN_INFO "%s: can't allocate vbi device\n",
725 			dev->name);
726 		result = -ENOMEM;
727 		goto failed;
728 	}
729 
730 	port->enc_port = &dev->ports[port->nr - 2];
731 	video_set_drvdata(port->v4l_device, port);
732 	result = video_register_device(port->v4l_device,
733 		VFL_TYPE_VBI, -1);
734 	if (result < 0) {
735 		printk(KERN_INFO "%s: can't register vbi device\n",
736 			dev->name);
737 		/* TODO: We're going to leak here if we don't dealloc
738 		 The buffers above. The unreg function can't deal wit it.
739 		*/
740 		goto failed;
741 	}
742 
743 	printk(KERN_INFO "%s: registered device vbi%d [vbi]\n",
744 		dev->name, port->v4l_device->num);
745 
746 	/* Configure the hardware defaults */
747 
748 	result = 0;
749 failed:
750 	return result;
751 }
752 
753 void saa7164_vbi_unregister(struct saa7164_port *port)
754 {
755 	struct saa7164_dev *dev = port->dev;
756 
757 	dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
758 
759 	if (port->type != SAA7164_MPEG_VBI)
760 		BUG();
761 
762 	if (port->v4l_device) {
763 		if (port->v4l_device->minor != -1)
764 			video_unregister_device(port->v4l_device);
765 		else
766 			video_device_release(port->v4l_device);
767 
768 		port->v4l_device = NULL;
769 	}
770 
771 }
772