1 /*
2 *
3 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include <linux/init.h>
21 #include <linux/list.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/delay.h>
26
27 #include "saa7134-reg.h"
28 #include "saa7134.h"
29
30 #include <media/saa6752hs.h>
31 #include <media/v4l2-common.h>
32
33 /* ------------------------------------------------------------------ */
34
35 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
36 MODULE_LICENSE("GPL");
37
38 static unsigned int empress_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
39
40 module_param_array(empress_nr, int, NULL, 0444);
41 MODULE_PARM_DESC(empress_nr,"ts device number");
42
43 static unsigned int debug = 0;
44 module_param(debug, int, 0644);
45 MODULE_PARM_DESC(debug,"enable debug messages");
46
47 #define dprintk(fmt, arg...) if (debug) \
48 printk(KERN_DEBUG "%s/empress: " fmt, dev->name , ## arg)
49
50 /* ------------------------------------------------------------------ */
51
52 static void ts_reset_encoder(struct saa7134_dev* dev)
53 {
54 if (!dev->empress_started)
55 return;
56
57 saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
58 msleep(10);
59 saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
60 msleep(100);
61 dev->empress_started = 0;
62 }
63
64 static int ts_init_encoder(struct saa7134_dev* dev)
65 {
66 struct v4l2_ext_controls ctrls = { V4L2_CTRL_CLASS_MPEG, 0 };
67
68 ts_reset_encoder(dev);
69 saa7134_i2c_call_clients(dev, VIDIOC_S_EXT_CTRLS, &ctrls);
70 dev->empress_started = 1;
71 return 0;
72 }
73
74 /* ------------------------------------------------------------------ */
75
76 static int ts_open(struct inode *inode, struct file *file)
77 {
78 int minor = iminor(inode);
79 struct saa7134_dev *dev;
80 int err;
81
82 list_for_each_entry(dev, &saa7134_devlist, devlist)
83 if (dev->empress_dev && dev->empress_dev->minor == minor)
84 goto found;
85 return -ENODEV;
86 found:
87
88 dprintk("open minor=%d\n",minor);
89 err = -EBUSY;
90 if (!mutex_trylock(&dev->empress_tsq.vb_lock))
91 goto done;
92 if (dev->empress_users)
93 goto done_up;
94
95 /* Unmute audio */
96 saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
97 saa_readb(SAA7134_AUDIO_MUTE_CTRL) & ~(1 << 6));
98
99 dev->empress_users++;
100 file->private_data = dev;
101 err = 0;
102
103 done_up:
104 mutex_unlock(&dev->empress_tsq.vb_lock);
105 done:
106 return err;
107 }
108
109 static int ts_release(struct inode *inode, struct file *file)
110 {
111 struct saa7134_dev *dev = file->private_data;
112
113 videobuf_stop(&dev->empress_tsq);
114 videobuf_mmap_free(&dev->empress_tsq);
115 dev->empress_users--;
116
117 /* stop the encoder */
118 ts_reset_encoder(dev);
119
120 /* Mute audio */
121 saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
122 saa_readb(SAA7134_AUDIO_MUTE_CTRL) | (1 << 6));
123
124 return 0;
125 }
126
127 static ssize_t
128 ts_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
129 {
130 struct saa7134_dev *dev = file->private_data;
131
132 if (!dev->empress_started)
133 ts_init_encoder(dev);
134
135 return videobuf_read_stream(&dev->empress_tsq,
136 data, count, ppos, 0,
137 file->f_flags & O_NONBLOCK);
138 }
139
140 static unsigned int
141 ts_poll(struct file *file, struct poll_table_struct *wait)
142 {
143 struct saa7134_dev *dev = file->private_data;
144
145 return videobuf_poll_stream(file, &dev->empress_tsq, wait);
146 }
147
148
149 static int
150 ts_mmap(struct file *file, struct vm_area_struct * vma)
151 {
152 struct saa7134_dev *dev = file->private_data;
153
154 return videobuf_mmap_mapper(&dev->empress_tsq, vma);
155 }
156
157 /*
158 * This function is _not_ called directly, but from
159 * video_generic_ioctl (and maybe others). userspace
160 * copying is done already, arg is a kernel pointer.
161 */
162
163 static int empress_querycap(struct file *file, void *priv,
164 struct v4l2_capability *cap)
165 {
166 struct saa7134_fh *fh = priv;
167 struct saa7134_dev *dev = fh->dev;
168
169 strcpy(cap->driver, "saa7134");
170 strlcpy(cap->card, saa7134_boards[dev->board].name,
171 sizeof(cap->card));
172 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
173 cap->version = SAA7134_VERSION_CODE;
174 cap->capabilities =
175 V4L2_CAP_VIDEO_CAPTURE |
176 V4L2_CAP_READWRITE |
177 V4L2_CAP_STREAMING;
178 return 0;
179 }
180
181 static int empress_enum_input(struct file *file, void *priv,
182 struct v4l2_input *i)
183 {
184 if (i->index != 0)
185 return -EINVAL;
186
187 i->type = V4L2_INPUT_TYPE_CAMERA;
188 strcpy(i->name, "CCIR656");
189
190 return 0;
191 }
192
193 static int empress_g_input(struct file *file, void *priv, unsigned int *i)
194 {
195 *i = 0;
196 return 0;
197 }
198
199 static int empress_s_input(struct file *file, void *priv, unsigned int i)
200 {
201 if (i != 0)
202 return -EINVAL;
203
204 return 0;
205 }
206
207 static int empress_enum_fmt_cap(struct file *file, void *priv,
208 struct v4l2_fmtdesc *f)
209 {
210 if (f->index != 0)
211 return -EINVAL;
212
213 strlcpy(f->description, "MPEG TS", sizeof(f->description));
214 f->pixelformat = V4L2_PIX_FMT_MPEG;
215
216 return 0;
217 }
218
219 static int empress_g_fmt_cap(struct file *file, void *priv,
220 struct v4l2_format *f)
221 {
222 struct saa7134_fh *fh = priv;
223 struct saa7134_dev *dev = fh->dev;
224
225 saa7134_i2c_call_clients(dev, VIDIOC_G_FMT, f);
226
227 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
228 f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets;
229
230 return 0;
231 }
232
233 static int empress_s_fmt_cap(struct file *file, void *priv,
234 struct v4l2_format *f)
235 {
236 struct saa7134_fh *fh = priv;
237 struct saa7134_dev *dev = fh->dev;
238
239 saa7134_i2c_call_clients(dev, VIDIOC_S_FMT, f);
240
241 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
242 f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets;
243
244 return 0;
245 }
246
247
248 static int empress_reqbufs(struct file *file, void *priv,
249 struct v4l2_requestbuffers *p)
250 {
251 struct saa7134_fh *fh = priv;
252 struct saa7134_dev *dev = fh->dev;
253
254 return videobuf_reqbufs(&dev->empress_tsq, p);
255 }
256
257 static int empress_querybuf(struct file *file, void *priv,
258 struct v4l2_buffer *b)
259 {
260 struct saa7134_fh *fh = priv;
261 struct saa7134_dev *dev = fh->dev;
262
263 return videobuf_querybuf(&dev->empress_tsq, b);
264 }
265
266 static int empress_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
267 {
268 struct saa7134_fh *fh = priv;
269 struct saa7134_dev *dev = fh->dev;
270
271 return videobuf_qbuf(&dev->empress_tsq, b);
272 }
273
274 static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
275 {
276 struct saa7134_fh *fh = priv;
277 struct saa7134_dev *dev = fh->dev;
278
279 return videobuf_dqbuf(&dev->empress_tsq, b,
280 file->f_flags & O_NONBLOCK);
281 }
282
283 static int empress_streamon(struct file *file, void *priv,
284 enum v4l2_buf_type type)
285 {
286 struct saa7134_fh *fh = priv;
287 struct saa7134_dev *dev = fh->dev;
288
289 return videobuf_streamon(&dev->empress_tsq);
290 }
291
292 static int empress_streamoff(struct file *file, void *priv,
293 enum v4l2_buf_type type)
294 {
295 struct saa7134_fh *fh = priv;
296 struct saa7134_dev *dev = fh->dev;
297
298 return videobuf_streamoff(&dev->empress_tsq);
299 }
300
301 static int empress_s_ext_ctrls(struct file *file, void *priv,
302 struct v4l2_ext_controls *ctrls)
303 {
304 struct saa7134_fh *fh = priv;
305 struct saa7134_dev *dev = fh->dev;
306
307 /* count == 0 is abused in saa6752hs.c, so that special
308 case is handled here explicitly. */
309 if (ctrls->count == 0)
310 return 0;
311
312 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
313 return -EINVAL;
314
315 saa7134_i2c_call_clients(dev, VIDIOC_S_EXT_CTRLS, ctrls);
316 ts_init_encoder(dev);
317
318 return 0;
319 }
320
321 static int empress_g_ext_ctrls(struct file *file, void *priv,
322 struct v4l2_ext_controls *ctrls)
323 {
324 struct saa7134_fh *fh = priv;
325 struct saa7134_dev *dev = fh->dev;
326
327 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
328 return -EINVAL;
329 saa7134_i2c_call_clients(dev, VIDIOC_G_EXT_CTRLS, ctrls);
330
331 return 0;
332 }
333
334 static const struct file_operations ts_fops =
335 {
336 .owner = THIS_MODULE,
337 .open = ts_open,
338 .release = ts_release,
339 .read = ts_read,
340 .poll = ts_poll,
341 .mmap = ts_mmap,
342 .ioctl = video_ioctl2,
343 .llseek = no_llseek,
344 };
345
346 /* ----------------------------------------------------------- */
347
348 static struct video_device saa7134_empress_template =
349 {
350 .name = "saa7134-empress",
351 .type = 0 /* FIXME */,
352 .type2 = 0 /* FIXME */,
353 .fops = &ts_fops,
354 .minor = -1,
355
356 .vidioc_querycap = empress_querycap,
357 .vidioc_enum_fmt_cap = empress_enum_fmt_cap,
358 .vidioc_s_fmt_cap = empress_s_fmt_cap,
359 .vidioc_g_fmt_cap = empress_g_fmt_cap,
360 .vidioc_reqbufs = empress_reqbufs,
361 .vidioc_querybuf = empress_querybuf,
362 .vidioc_qbuf = empress_qbuf,
363 .vidioc_dqbuf = empress_dqbuf,
364 .vidioc_streamon = empress_streamon,
365 .vidioc_streamoff = empress_streamoff,
366 .vidioc_s_ext_ctrls = empress_s_ext_ctrls,
367 .vidioc_g_ext_ctrls = empress_g_ext_ctrls,
368 .vidioc_enum_input = empress_enum_input,
369 .vidioc_g_input = empress_g_input,
370 .vidioc_s_input = empress_s_input,
371
372 .vidioc_queryctrl = saa7134_queryctrl,
373 .vidioc_g_ctrl = saa7134_g_ctrl,
374 .vidioc_s_ctrl = saa7134_s_ctrl,
375
376 .tvnorms = SAA7134_NORMS,
377 .current_norm = V4L2_STD_PAL,
378 };
379
380 static void empress_signal_update(struct work_struct *work)
381 {
382 struct saa7134_dev* dev =
383 container_of(work, struct saa7134_dev, empress_workqueue);
384
385 if (dev->nosignal) {
386 dprintk("no video signal\n");
387 ts_reset_encoder(dev);
388 } else {
389 dprintk("video signal acquired\n");
390 if (dev->empress_users)
391 ts_init_encoder(dev);
392 }
393 }
394
395 static void empress_signal_change(struct saa7134_dev *dev)
396 {
397 schedule_work(&dev->empress_workqueue);
398 }
399
400
401 static int empress_init(struct saa7134_dev *dev)
402 {
403 int err;
404
405 dprintk("%s: %s\n",dev->name,__FUNCTION__);
406 dev->empress_dev = video_device_alloc();
407 if (NULL == dev->empress_dev)
408 return -ENOMEM;
409 *(dev->empress_dev) = saa7134_empress_template;
410 dev->empress_dev->dev = &dev->pci->dev;
411 dev->empress_dev->release = video_device_release;
412 snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name),
413 "%s empress (%s)", dev->name,
414 saa7134_boards[dev->board].name);
415
416 INIT_WORK(&dev->empress_workqueue, empress_signal_update);
417
418 err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,
419 empress_nr[dev->nr]);
420 if (err < 0) {
421 printk(KERN_INFO "%s: can't register video device\n",
422 dev->name);
423 video_device_release(dev->empress_dev);
424 dev->empress_dev = NULL;
425 return err;
426 }
427 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
428 dev->name,dev->empress_dev->minor & 0x1f);
429
430 videobuf_queue_pci_init(&dev->empress_tsq, &saa7134_ts_qops,
431 dev->pci, &dev->slock,
432 V4L2_BUF_TYPE_VIDEO_CAPTURE,
433 V4L2_FIELD_ALTERNATE,
434 sizeof(struct saa7134_buf),
435 dev);
436
437 empress_signal_update(&dev->empress_workqueue);
438 return 0;
439 }
440
441 static int empress_fini(struct saa7134_dev *dev)
442 {
443 dprintk("%s: %s\n",dev->name,__FUNCTION__);
444
445 if (NULL == dev->empress_dev)
446 return 0;
447 flush_scheduled_work();
448 video_unregister_device(dev->empress_dev);
449 dev->empress_dev = NULL;
450 return 0;
451 }
452
453 static struct saa7134_mpeg_ops empress_ops = {
454 .type = SAA7134_MPEG_EMPRESS,
455 .init = empress_init,
456 .fini = empress_fini,
457 .signal_change = empress_signal_change,
458 };
459
460 static int __init empress_register(void)
461 {
462 return saa7134_ts_register(&empress_ops);
463 }
464
465 static void __exit empress_unregister(void)
466 {
467 saa7134_ts_unregister(&empress_ops);
468 }
469
470 module_init(empress_register);
471 module_exit(empress_unregister);
472
473 /* ----------------------------------------------------------- */
474 /*
475 * Local variables:
476 * c-basic-offset: 8
477 * End:
478 */
479
|
This page was automatically generated by the
LXR engine.
|