V4L/DVB (8613): v4l: move BKL down to the driver level.
[linux-3.10.git] / 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         lock_kernel();
83         list_for_each_entry(dev, &saa7134_devlist, devlist)
84                 if (dev->empress_dev && dev->empress_dev->minor == minor)
85                         goto found;
86         unlock_kernel();
87         return -ENODEV;
88  found:
89
90         dprintk("open minor=%d\n",minor);
91         err = -EBUSY;
92         if (!mutex_trylock(&dev->empress_tsq.vb_lock))
93                 goto done;
94         if (atomic_read(&dev->empress_users))
95                 goto done_up;
96
97         /* Unmute audio */
98         saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
99                 saa_readb(SAA7134_AUDIO_MUTE_CTRL) & ~(1 << 6));
100
101         atomic_inc(&dev->empress_users);
102         file->private_data = dev;
103         err = 0;
104
105 done_up:
106         mutex_unlock(&dev->empress_tsq.vb_lock);
107 done:
108         unlock_kernel();
109         return err;
110 }
111
112 static int ts_release(struct inode *inode, struct file *file)
113 {
114         struct saa7134_dev *dev = file->private_data;
115
116         videobuf_stop(&dev->empress_tsq);
117         videobuf_mmap_free(&dev->empress_tsq);
118
119         /* stop the encoder */
120         ts_reset_encoder(dev);
121
122         /* Mute audio */
123         saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
124                 saa_readb(SAA7134_AUDIO_MUTE_CTRL) | (1 << 6));
125
126         atomic_dec(&dev->empress_users);
127
128         return 0;
129 }
130
131 static ssize_t
132 ts_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
133 {
134         struct saa7134_dev *dev = file->private_data;
135
136         if (!dev->empress_started)
137                 ts_init_encoder(dev);
138
139         return videobuf_read_stream(&dev->empress_tsq,
140                                     data, count, ppos, 0,
141                                     file->f_flags & O_NONBLOCK);
142 }
143
144 static unsigned int
145 ts_poll(struct file *file, struct poll_table_struct *wait)
146 {
147         struct saa7134_dev *dev = file->private_data;
148
149         return videobuf_poll_stream(file, &dev->empress_tsq, wait);
150 }
151
152
153 static int
154 ts_mmap(struct file *file, struct vm_area_struct * vma)
155 {
156         struct saa7134_dev *dev = file->private_data;
157
158         return videobuf_mmap_mapper(&dev->empress_tsq, vma);
159 }
160
161 /*
162  * This function is _not_ called directly, but from
163  * video_generic_ioctl (and maybe others).  userspace
164  * copying is done already, arg is a kernel pointer.
165  */
166
167 static int empress_querycap(struct file *file, void  *priv,
168                                         struct v4l2_capability *cap)
169 {
170         struct saa7134_dev *dev = file->private_data;
171
172         strcpy(cap->driver, "saa7134");
173         strlcpy(cap->card, saa7134_boards[dev->board].name,
174                 sizeof(cap->card));
175         sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
176         cap->version = SAA7134_VERSION_CODE;
177         cap->capabilities =
178                 V4L2_CAP_VIDEO_CAPTURE |
179                 V4L2_CAP_READWRITE |
180                 V4L2_CAP_STREAMING;
181         return 0;
182 }
183
184 static int empress_enum_input(struct file *file, void *priv,
185                                         struct v4l2_input *i)
186 {
187         if (i->index != 0)
188                 return -EINVAL;
189
190         i->type = V4L2_INPUT_TYPE_CAMERA;
191         strcpy(i->name, "CCIR656");
192
193         return 0;
194 }
195
196 static int empress_g_input(struct file *file, void *priv, unsigned int *i)
197 {
198         *i = 0;
199         return 0;
200 }
201
202 static int empress_s_input(struct file *file, void *priv, unsigned int i)
203 {
204         if (i != 0)
205                 return -EINVAL;
206
207         return 0;
208 }
209
210 static int empress_enum_fmt_vid_cap(struct file *file, void  *priv,
211                                         struct v4l2_fmtdesc *f)
212 {
213         if (f->index != 0)
214                 return -EINVAL;
215
216         strlcpy(f->description, "MPEG TS", sizeof(f->description));
217         f->pixelformat = V4L2_PIX_FMT_MPEG;
218
219         return 0;
220 }
221
222 static int empress_g_fmt_vid_cap(struct file *file, void *priv,
223                                 struct v4l2_format *f)
224 {
225         struct saa7134_dev *dev = file->private_data;
226
227         saa7134_i2c_call_clients(dev, VIDIOC_G_FMT, f);
228
229         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
230         f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
231
232         return 0;
233 }
234
235 static int empress_s_fmt_vid_cap(struct file *file, void *priv,
236                                 struct v4l2_format *f)
237 {
238         struct saa7134_dev *dev = file->private_data;
239
240         saa7134_i2c_call_clients(dev, VIDIOC_S_FMT, f);
241
242         f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
243         f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
244
245         return 0;
246 }
247
248
249 static int empress_reqbufs(struct file *file, void *priv,
250                                         struct v4l2_requestbuffers *p)
251 {
252         struct saa7134_dev *dev = file->private_data;
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_dev *dev = file->private_data;
261
262         return videobuf_querybuf(&dev->empress_tsq, b);
263 }
264
265 static int empress_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
266 {
267         struct saa7134_dev *dev = file->private_data;
268
269         return videobuf_qbuf(&dev->empress_tsq, b);
270 }
271
272 static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
273 {
274         struct saa7134_dev *dev = file->private_data;
275
276         return videobuf_dqbuf(&dev->empress_tsq, b,
277                                 file->f_flags & O_NONBLOCK);
278 }
279
280 static int empress_streamon(struct file *file, void *priv,
281                                         enum v4l2_buf_type type)
282 {
283         struct saa7134_dev *dev = file->private_data;
284
285         return videobuf_streamon(&dev->empress_tsq);
286 }
287
288 static int empress_streamoff(struct file *file, void *priv,
289                                         enum v4l2_buf_type type)
290 {
291         struct saa7134_dev *dev = file->private_data;
292
293         return videobuf_streamoff(&dev->empress_tsq);
294 }
295
296 static int saa7134_i2c_call_saa6752(struct saa7134_dev *dev,
297                                               unsigned int cmd, void *arg)
298 {
299         if (dev->mpeg_i2c_client == NULL)
300                 return -EINVAL;
301         return dev->mpeg_i2c_client->driver->command(dev->mpeg_i2c_client,
302                                                                 cmd, arg);
303 }
304
305 static int empress_s_ext_ctrls(struct file *file, void *priv,
306                                struct v4l2_ext_controls *ctrls)
307 {
308         struct saa7134_dev *dev = file->private_data;
309         int err;
310
311         /* count == 0 is abused in saa6752hs.c, so that special
312                 case is handled here explicitly. */
313         if (ctrls->count == 0)
314                 return 0;
315
316         if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
317                 return -EINVAL;
318
319         err = saa7134_i2c_call_saa6752(dev, VIDIOC_S_EXT_CTRLS, ctrls);
320         ts_init_encoder(dev);
321
322         return err;
323 }
324
325 static int empress_g_ext_ctrls(struct file *file, void *priv,
326                                struct v4l2_ext_controls *ctrls)
327 {
328         struct saa7134_dev *dev = file->private_data;
329
330         if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
331                 return -EINVAL;
332         return saa7134_i2c_call_saa6752(dev, VIDIOC_G_EXT_CTRLS, ctrls);
333 }
334
335 static int empress_g_ctrl(struct file *file, void *priv,
336                                         struct v4l2_control *c)
337 {
338         struct saa7134_dev *dev = file->private_data;
339
340         return saa7134_g_ctrl_internal(dev, NULL, c);
341 }
342
343 static int empress_s_ctrl(struct file *file, void *priv,
344                                         struct v4l2_control *c)
345 {
346         struct saa7134_dev *dev = file->private_data;
347
348         return saa7134_s_ctrl_internal(dev, NULL, c);
349 }
350
351 static int empress_queryctrl(struct file *file, void *priv,
352                                         struct v4l2_queryctrl *c)
353 {
354         static const u32 user_ctrls[] = {
355                 V4L2_CID_USER_CLASS,
356                 V4L2_CID_BRIGHTNESS,
357                 V4L2_CID_CONTRAST,
358                 V4L2_CID_SATURATION,
359                 V4L2_CID_HUE,
360                 V4L2_CID_AUDIO_VOLUME,
361                 V4L2_CID_AUDIO_MUTE,
362                 V4L2_CID_HFLIP,
363                 0
364         };
365
366         static const u32 mpeg_ctrls[] = {
367                 V4L2_CID_MPEG_CLASS,
368                 V4L2_CID_MPEG_STREAM_TYPE,
369                 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
370                 V4L2_CID_MPEG_AUDIO_ENCODING,
371                 V4L2_CID_MPEG_AUDIO_L2_BITRATE,
372                 V4L2_CID_MPEG_VIDEO_ENCODING,
373                 V4L2_CID_MPEG_VIDEO_ASPECT,
374                 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
375                 V4L2_CID_MPEG_VIDEO_BITRATE,
376                 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
377                 0
378         };
379         static const u32 *ctrl_classes[] = {
380                 user_ctrls,
381                 mpeg_ctrls,
382                 NULL
383         };
384         struct saa7134_dev *dev = file->private_data;
385
386         c->id = v4l2_ctrl_next(ctrl_classes, c->id);
387         if (c->id == 0)
388                 return -EINVAL;
389         if (c->id == V4L2_CID_USER_CLASS || c->id == V4L2_CID_MPEG_CLASS)
390                 return v4l2_ctrl_query_fill_std(c);
391         if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
392                 return saa7134_queryctrl(file, priv, c);
393         return saa7134_i2c_call_saa6752(dev, VIDIOC_QUERYCTRL, c);
394 }
395
396 static int empress_querymenu(struct file *file, void *priv,
397                                         struct v4l2_querymenu *c)
398 {
399         struct saa7134_dev *dev = file->private_data;
400
401         if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
402                 return -EINVAL;
403         return saa7134_i2c_call_saa6752(dev, VIDIOC_QUERYMENU, c);
404 }
405
406 static const struct file_operations ts_fops =
407 {
408         .owner    = THIS_MODULE,
409         .open     = ts_open,
410         .release  = ts_release,
411         .read     = ts_read,
412         .poll     = ts_poll,
413         .mmap     = ts_mmap,
414         .ioctl    = video_ioctl2,
415         .llseek   = no_llseek,
416 };
417
418 static const struct v4l2_ioctl_ops ts_ioctl_ops = {
419         .vidioc_querycap                = empress_querycap,
420         .vidioc_enum_fmt_vid_cap        = empress_enum_fmt_vid_cap,
421         .vidioc_s_fmt_vid_cap           = empress_s_fmt_vid_cap,
422         .vidioc_g_fmt_vid_cap           = empress_g_fmt_vid_cap,
423         .vidioc_reqbufs                 = empress_reqbufs,
424         .vidioc_querybuf                = empress_querybuf,
425         .vidioc_qbuf                    = empress_qbuf,
426         .vidioc_dqbuf                   = empress_dqbuf,
427         .vidioc_streamon                = empress_streamon,
428         .vidioc_streamoff               = empress_streamoff,
429         .vidioc_s_ext_ctrls             = empress_s_ext_ctrls,
430         .vidioc_g_ext_ctrls             = empress_g_ext_ctrls,
431         .vidioc_enum_input              = empress_enum_input,
432         .vidioc_g_input                 = empress_g_input,
433         .vidioc_s_input                 = empress_s_input,
434
435         .vidioc_queryctrl               = empress_queryctrl,
436         .vidioc_querymenu               = empress_querymenu,
437         .vidioc_g_ctrl                  = empress_g_ctrl,
438         .vidioc_s_ctrl                  = empress_s_ctrl,
439 };
440
441 /* ----------------------------------------------------------- */
442
443 static struct video_device saa7134_empress_template = {
444         .name          = "saa7134-empress",
445         .fops          = &ts_fops,
446         .minor         = -1,
447         .ioctl_ops     = &ts_ioctl_ops,
448
449         .tvnorms                        = SAA7134_NORMS,
450         .current_norm                   = V4L2_STD_PAL,
451 };
452
453 static void empress_signal_update(struct work_struct *work)
454 {
455         struct saa7134_dev* dev =
456                 container_of(work, struct saa7134_dev, empress_workqueue);
457
458         if (dev->nosignal) {
459                 dprintk("no video signal\n");
460                 ts_reset_encoder(dev);
461         } else {
462                 dprintk("video signal acquired\n");
463                 if (atomic_read(&dev->empress_users))
464                         ts_init_encoder(dev);
465         }
466 }
467
468 static void empress_signal_change(struct saa7134_dev *dev)
469 {
470         schedule_work(&dev->empress_workqueue);
471 }
472
473
474 static int empress_init(struct saa7134_dev *dev)
475 {
476         int err;
477
478         dprintk("%s: %s\n",dev->name,__func__);
479         dev->empress_dev = video_device_alloc();
480         if (NULL == dev->empress_dev)
481                 return -ENOMEM;
482         *(dev->empress_dev) = saa7134_empress_template;
483         dev->empress_dev->parent  = &dev->pci->dev;
484         dev->empress_dev->release = video_device_release;
485         snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name),
486                  "%s empress (%s)", dev->name,
487                  saa7134_boards[dev->board].name);
488
489         INIT_WORK(&dev->empress_workqueue, empress_signal_update);
490
491         err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,
492                                     empress_nr[dev->nr]);
493         if (err < 0) {
494                 printk(KERN_INFO "%s: can't register video device\n",
495                        dev->name);
496                 video_device_release(dev->empress_dev);
497                 dev->empress_dev = NULL;
498                 return err;
499         }
500         printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
501                dev->name,dev->empress_dev->minor & 0x1f);
502
503         videobuf_queue_sg_init(&dev->empress_tsq, &saa7134_ts_qops,
504                             &dev->pci->dev, &dev->slock,
505                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
506                             V4L2_FIELD_ALTERNATE,
507                             sizeof(struct saa7134_buf),
508                             dev);
509
510         empress_signal_update(&dev->empress_workqueue);
511         return 0;
512 }
513
514 static int empress_fini(struct saa7134_dev *dev)
515 {
516         dprintk("%s: %s\n",dev->name,__func__);
517
518         if (NULL == dev->empress_dev)
519                 return 0;
520         flush_scheduled_work();
521         video_unregister_device(dev->empress_dev);
522         dev->empress_dev = NULL;
523         return 0;
524 }
525
526 static struct saa7134_mpeg_ops empress_ops = {
527         .type          = SAA7134_MPEG_EMPRESS,
528         .init          = empress_init,
529         .fini          = empress_fini,
530         .signal_change = empress_signal_change,
531 };
532
533 static int __init empress_register(void)
534 {
535         return saa7134_ts_register(&empress_ops);
536 }
537
538 static void __exit empress_unregister(void)
539 {
540         saa7134_ts_unregister(&empress_ops);
541 }
542
543 module_init(empress_register);
544 module_exit(empress_unregister);
545
546 /* ----------------------------------------------------------- */
547 /*
548  * Local variables:
549  * c-basic-offset: 8
550  * End:
551  */