Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
0005  */
0006 
0007 #include "saa7134.h"
0008 #include "saa7134-reg.h"
0009 
0010 #include <linux/init.h>
0011 #include <linux/list.h>
0012 #include <linux/module.h>
0013 #include <linux/kernel.h>
0014 #include <linux/delay.h>
0015 
0016 #include <media/v4l2-common.h>
0017 #include <media/v4l2-event.h>
0018 
0019 /* ------------------------------------------------------------------ */
0020 
0021 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
0022 MODULE_LICENSE("GPL");
0023 
0024 static unsigned int empress_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
0025 
0026 module_param_array(empress_nr, int, NULL, 0444);
0027 MODULE_PARM_DESC(empress_nr,"ts device number");
0028 
0029 /* ------------------------------------------------------------------ */
0030 
0031 static int start_streaming(struct vb2_queue *vq, unsigned int count)
0032 {
0033     struct saa7134_dmaqueue *dmaq = vq->drv_priv;
0034     struct saa7134_dev *dev = dmaq->dev;
0035     u32 leading_null_bytes = 0;
0036     int err;
0037 
0038     err = saa7134_ts_start_streaming(vq, count);
0039     if (err)
0040         return err;
0041 
0042     /* If more cards start to need this, then this
0043        should probably be added to the card definitions. */
0044     switch (dev->board) {
0045     case SAA7134_BOARD_BEHOLD_M6:
0046     case SAA7134_BOARD_BEHOLD_M63:
0047     case SAA7134_BOARD_BEHOLD_M6_EXTRA:
0048         leading_null_bytes = 1;
0049         break;
0050     }
0051     saa_call_all(dev, core, init, leading_null_bytes);
0052     /* Unmute audio */
0053     saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
0054             saa_readb(SAA7134_AUDIO_MUTE_CTRL) & ~(1 << 6));
0055     dev->empress_started = 1;
0056     return 0;
0057 }
0058 
0059 static void stop_streaming(struct vb2_queue *vq)
0060 {
0061     struct saa7134_dmaqueue *dmaq = vq->drv_priv;
0062     struct saa7134_dev *dev = dmaq->dev;
0063 
0064     saa7134_ts_stop_streaming(vq);
0065     saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
0066     msleep(20);
0067     saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
0068     msleep(100);
0069     /* Mute audio */
0070     saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
0071             saa_readb(SAA7134_AUDIO_MUTE_CTRL) | (1 << 6));
0072     dev->empress_started = 0;
0073 }
0074 
0075 static const struct vb2_ops saa7134_empress_qops = {
0076     .queue_setup    = saa7134_ts_queue_setup,
0077     .buf_init   = saa7134_ts_buffer_init,
0078     .buf_prepare    = saa7134_ts_buffer_prepare,
0079     .buf_queue  = saa7134_vb2_buffer_queue,
0080     .wait_prepare   = vb2_ops_wait_prepare,
0081     .wait_finish    = vb2_ops_wait_finish,
0082     .start_streaming = start_streaming,
0083     .stop_streaming = stop_streaming,
0084 };
0085 
0086 /* ------------------------------------------------------------------ */
0087 
0088 static int empress_enum_fmt_vid_cap(struct file *file, void  *priv,
0089                     struct v4l2_fmtdesc *f)
0090 {
0091     if (f->index != 0)
0092         return -EINVAL;
0093 
0094     f->pixelformat = V4L2_PIX_FMT_MPEG;
0095     return 0;
0096 }
0097 
0098 static int empress_g_fmt_vid_cap(struct file *file, void *priv,
0099                 struct v4l2_format *f)
0100 {
0101     struct saa7134_dev *dev = video_drvdata(file);
0102     struct v4l2_subdev_format fmt = {
0103         .which = V4L2_SUBDEV_FORMAT_ACTIVE,
0104     };
0105     struct v4l2_mbus_framefmt *mbus_fmt = &fmt.format;
0106 
0107     saa_call_all(dev, pad, get_fmt, NULL, &fmt);
0108 
0109     v4l2_fill_pix_format(&f->fmt.pix, mbus_fmt);
0110     f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
0111     f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
0112     f->fmt.pix.bytesperline = 0;
0113 
0114     return 0;
0115 }
0116 
0117 static int empress_s_fmt_vid_cap(struct file *file, void *priv,
0118                 struct v4l2_format *f)
0119 {
0120     struct saa7134_dev *dev = video_drvdata(file);
0121     struct v4l2_subdev_format format = {
0122         .which = V4L2_SUBDEV_FORMAT_ACTIVE,
0123     };
0124 
0125     v4l2_fill_mbus_format(&format.format, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
0126     saa_call_all(dev, pad, set_fmt, NULL, &format);
0127     v4l2_fill_pix_format(&f->fmt.pix, &format.format);
0128 
0129     f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
0130     f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
0131     f->fmt.pix.bytesperline = 0;
0132 
0133     return 0;
0134 }
0135 
0136 static int empress_try_fmt_vid_cap(struct file *file, void *priv,
0137                 struct v4l2_format *f)
0138 {
0139     struct saa7134_dev *dev = video_drvdata(file);
0140     struct v4l2_subdev_pad_config pad_cfg;
0141     struct v4l2_subdev_state pad_state = {
0142         .pads = &pad_cfg
0143         };
0144     struct v4l2_subdev_format format = {
0145         .which = V4L2_SUBDEV_FORMAT_TRY,
0146     };
0147 
0148     v4l2_fill_mbus_format(&format.format, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
0149     saa_call_all(dev, pad, set_fmt, &pad_state, &format);
0150     v4l2_fill_pix_format(&f->fmt.pix, &format.format);
0151 
0152     f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
0153     f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
0154     f->fmt.pix.bytesperline = 0;
0155 
0156     return 0;
0157 }
0158 
0159 static const struct v4l2_file_operations ts_fops =
0160 {
0161     .owner    = THIS_MODULE,
0162     .open     = v4l2_fh_open,
0163     .release  = vb2_fop_release,
0164     .read     = vb2_fop_read,
0165     .poll     = vb2_fop_poll,
0166     .mmap     = vb2_fop_mmap,
0167     .unlocked_ioctl = video_ioctl2,
0168 };
0169 
0170 static const struct v4l2_ioctl_ops ts_ioctl_ops = {
0171     .vidioc_querycap        = saa7134_querycap,
0172     .vidioc_enum_fmt_vid_cap    = empress_enum_fmt_vid_cap,
0173     .vidioc_try_fmt_vid_cap     = empress_try_fmt_vid_cap,
0174     .vidioc_s_fmt_vid_cap       = empress_s_fmt_vid_cap,
0175     .vidioc_g_fmt_vid_cap       = empress_g_fmt_vid_cap,
0176     .vidioc_reqbufs         = vb2_ioctl_reqbufs,
0177     .vidioc_querybuf        = vb2_ioctl_querybuf,
0178     .vidioc_qbuf            = vb2_ioctl_qbuf,
0179     .vidioc_dqbuf           = vb2_ioctl_dqbuf,
0180     .vidioc_expbuf          = vb2_ioctl_expbuf,
0181     .vidioc_streamon        = vb2_ioctl_streamon,
0182     .vidioc_streamoff       = vb2_ioctl_streamoff,
0183     .vidioc_g_frequency     = saa7134_g_frequency,
0184     .vidioc_s_frequency     = saa7134_s_frequency,
0185     .vidioc_g_tuner         = saa7134_g_tuner,
0186     .vidioc_s_tuner         = saa7134_s_tuner,
0187     .vidioc_enum_input      = saa7134_enum_input,
0188     .vidioc_g_input         = saa7134_g_input,
0189     .vidioc_s_input         = saa7134_s_input,
0190     .vidioc_s_std           = saa7134_s_std,
0191     .vidioc_g_std           = saa7134_g_std,
0192     .vidioc_querystd        = saa7134_querystd,
0193     .vidioc_log_status      = v4l2_ctrl_log_status,
0194     .vidioc_subscribe_event     = v4l2_ctrl_subscribe_event,
0195     .vidioc_unsubscribe_event   = v4l2_event_unsubscribe,
0196 };
0197 
0198 /* ----------------------------------------------------------- */
0199 
0200 static const struct video_device saa7134_empress_template = {
0201     .name          = "saa7134-empress",
0202     .fops          = &ts_fops,
0203     .ioctl_ops     = &ts_ioctl_ops,
0204 
0205     .tvnorms            = SAA7134_NORMS,
0206 };
0207 
0208 static void empress_signal_update(struct work_struct *work)
0209 {
0210     struct saa7134_dev* dev =
0211         container_of(work, struct saa7134_dev, empress_workqueue);
0212 
0213     if (dev->nosignal) {
0214         pr_debug("no video signal\n");
0215     } else {
0216         pr_debug("video signal acquired\n");
0217     }
0218 }
0219 
0220 static void empress_signal_change(struct saa7134_dev *dev)
0221 {
0222     schedule_work(&dev->empress_workqueue);
0223 }
0224 
0225 static bool empress_ctrl_filter(const struct v4l2_ctrl *ctrl)
0226 {
0227     switch (ctrl->id) {
0228     case V4L2_CID_BRIGHTNESS:
0229     case V4L2_CID_HUE:
0230     case V4L2_CID_CONTRAST:
0231     case V4L2_CID_SATURATION:
0232     case V4L2_CID_AUDIO_MUTE:
0233     case V4L2_CID_AUDIO_VOLUME:
0234     case V4L2_CID_PRIVATE_INVERT:
0235     case V4L2_CID_PRIVATE_AUTOMUTE:
0236         return true;
0237     default:
0238         return false;
0239     }
0240 }
0241 
0242 static int empress_init(struct saa7134_dev *dev)
0243 {
0244     struct v4l2_ctrl_handler *hdl = &dev->empress_ctrl_handler;
0245     struct vb2_queue *q;
0246     int err;
0247 
0248     pr_debug("%s: %s\n", dev->name, __func__);
0249     dev->empress_dev = video_device_alloc();
0250     if (NULL == dev->empress_dev)
0251         return -ENOMEM;
0252     *(dev->empress_dev) = saa7134_empress_template;
0253     dev->empress_dev->v4l2_dev  = &dev->v4l2_dev;
0254     dev->empress_dev->release = video_device_release;
0255     dev->empress_dev->lock = &dev->lock;
0256     snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name),
0257          "%s empress (%s)", dev->name,
0258          saa7134_boards[dev->board].name);
0259     v4l2_ctrl_handler_init(hdl, 21);
0260     v4l2_ctrl_add_handler(hdl, &dev->ctrl_handler, empress_ctrl_filter, false);
0261     if (dev->empress_sd)
0262         v4l2_ctrl_add_handler(hdl, dev->empress_sd->ctrl_handler, NULL, true);
0263     if (hdl->error) {
0264         video_device_release(dev->empress_dev);
0265         return hdl->error;
0266     }
0267     dev->empress_dev->ctrl_handler = hdl;
0268 
0269     INIT_WORK(&dev->empress_workqueue, empress_signal_update);
0270 
0271     q = &dev->empress_vbq;
0272     q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
0273     /*
0274      * Do not add VB2_USERPTR: the saa7134 DMA engine cannot handle
0275      * transfers that do not start at the beginning of a page. A USERPTR
0276      * can start anywhere in a page, so USERPTR support is a no-go.
0277      */
0278     q->io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
0279     q->drv_priv = &dev->ts_q;
0280     q->ops = &saa7134_empress_qops;
0281     q->gfp_flags = GFP_DMA32;
0282     q->mem_ops = &vb2_dma_sg_memops;
0283     q->buf_struct_size = sizeof(struct saa7134_buf);
0284     q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
0285     q->lock = &dev->lock;
0286     q->dev = &dev->pci->dev;
0287     err = vb2_queue_init(q);
0288     if (err) {
0289         video_device_release(dev->empress_dev);
0290         dev->empress_dev = NULL;
0291         return err;
0292     }
0293     dev->empress_dev->queue = q;
0294     dev->empress_dev->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
0295                     V4L2_CAP_VIDEO_CAPTURE;
0296     if (dev->tuner_type != TUNER_ABSENT && dev->tuner_type != UNSET)
0297         dev->empress_dev->device_caps |= V4L2_CAP_TUNER;
0298 
0299     video_set_drvdata(dev->empress_dev, dev);
0300     err = video_register_device(dev->empress_dev,VFL_TYPE_VIDEO,
0301                     empress_nr[dev->nr]);
0302     if (err < 0) {
0303         pr_info("%s: can't register video device\n",
0304                dev->name);
0305         video_device_release(dev->empress_dev);
0306         dev->empress_dev = NULL;
0307         return err;
0308     }
0309     pr_info("%s: registered device %s [mpeg]\n",
0310            dev->name, video_device_node_name(dev->empress_dev));
0311 
0312     empress_signal_update(&dev->empress_workqueue);
0313     return 0;
0314 }
0315 
0316 static int empress_fini(struct saa7134_dev *dev)
0317 {
0318     pr_debug("%s: %s\n", dev->name, __func__);
0319 
0320     if (NULL == dev->empress_dev)
0321         return 0;
0322     flush_work(&dev->empress_workqueue);
0323     vb2_video_unregister_device(dev->empress_dev);
0324     v4l2_ctrl_handler_free(&dev->empress_ctrl_handler);
0325     dev->empress_dev = NULL;
0326     return 0;
0327 }
0328 
0329 static struct saa7134_mpeg_ops empress_ops = {
0330     .type          = SAA7134_MPEG_EMPRESS,
0331     .init          = empress_init,
0332     .fini          = empress_fini,
0333     .signal_change = empress_signal_change,
0334 };
0335 
0336 static int __init empress_register(void)
0337 {
0338     return saa7134_ts_register(&empress_ops);
0339 }
0340 
0341 static void __exit empress_unregister(void)
0342 {
0343     saa7134_ts_unregister(&empress_ops);
0344 }
0345 
0346 module_init(empress_register);
0347 module_exit(empress_unregister);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!