Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / drivers / media / video / saa7134 / saa7134-empress.c
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;
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,__func__);
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_sg_init(&dev->empress_tsq, &saa7134_ts_qops,
431                             &dev->pci->dev, &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,__func__);
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  */