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/delay.h> 25 26 #include "saa7134-reg.h" 27 #include "saa7134.h" 28 29 #include <media/saa6752hs.h> 30 #include <media/v4l2-common.h> 31 32 /* ------------------------------------------------------------------ */ 33 34 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]"); 35 MODULE_LICENSE("GPL"); 36 37 static unsigned int empress_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET }; 38 39 module_param_array(empress_nr, int, NULL, 0444); 40 MODULE_PARM_DESC(empress_nr,"ts device number"); 41 42 static unsigned int debug; 43 module_param(debug, int, 0644); 44 MODULE_PARM_DESC(debug,"enable debug messages"); 45 46 #define dprintk(fmt, arg...) if (debug) \ 47 printk(KERN_DEBUG "%s/empress: " fmt, dev->name , ## arg) 48 49 /* ------------------------------------------------------------------ */ 50 51 static void ts_reset_encoder(struct saa7134_dev* dev) 52 { 53 if (!dev->empress_started) 54 return; 55 56 saa_writeb(SAA7134_SPECIAL_MODE, 0x00); 57 msleep(10); 58 saa_writeb(SAA7134_SPECIAL_MODE, 0x01); 59 msleep(100); 60 dev->empress_started = 0; 61 } 62 63 static int ts_init_encoder(struct saa7134_dev* dev) 64 { 65 u32 leading_null_bytes = 0; 66 67 /* If more cards start to need this, then this 68 should probably be added to the card definitions. */ 69 switch (dev->board) { 70 case SAA7134_BOARD_BEHOLD_M6: 71 case SAA7134_BOARD_BEHOLD_M63: 72 case SAA7134_BOARD_BEHOLD_M6_EXTRA: 73 leading_null_bytes = 1; 74 break; 75 } 76 ts_reset_encoder(dev); 77 saa_call_all(dev, core, init, leading_null_bytes); 78 dev->empress_started = 1; 79 return 0; 80 } 81 82 /* ------------------------------------------------------------------ */ 83 84 static int ts_open(struct file *file) 85 { 86 struct video_device *vdev = video_devdata(file); 87 struct saa7134_dev *dev = video_drvdata(file); 88 int err; 89 90 dprintk("open dev=%s\n", video_device_node_name(vdev)); 91 err = -EBUSY; 92 if (!mutex_trylock(&dev->empress_tsq.vb_lock)) 93 return err; 94 if (atomic_read(&dev->empress_users)) 95 goto done; 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: 106 mutex_unlock(&dev->empress_tsq.vb_lock); 107 return err; 108 } 109 110 static int ts_release(struct file *file) 111 { 112 struct saa7134_dev *dev = file->private_data; 113 114 videobuf_stop(&dev->empress_tsq); 115 videobuf_mmap_free(&dev->empress_tsq); 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 atomic_dec(&dev->empress_users); 125 126 return 0; 127 } 128 129 static ssize_t 130 ts_read(struct file *file, char __user *data, size_t count, loff_t *ppos) 131 { 132 struct saa7134_dev *dev = file->private_data; 133 134 if (!dev->empress_started) 135 ts_init_encoder(dev); 136 137 return videobuf_read_stream(&dev->empress_tsq, 138 data, count, ppos, 0, 139 file->f_flags & O_NONBLOCK); 140 } 141 142 static unsigned int 143 ts_poll(struct file *file, struct poll_table_struct *wait) 144 { 145 struct saa7134_dev *dev = file->private_data; 146 147 return videobuf_poll_stream(file, &dev->empress_tsq, wait); 148 } 149 150 151 static int 152 ts_mmap(struct file *file, struct vm_area_struct * vma) 153 { 154 struct saa7134_dev *dev = file->private_data; 155 156 return videobuf_mmap_mapper(&dev->empress_tsq, vma); 157 } 158 159 /* 160 * This function is _not_ called directly, but from 161 * video_generic_ioctl (and maybe others). userspace 162 * copying is done already, arg is a kernel pointer. 163 */ 164 165 static int empress_querycap(struct file *file, void *priv, 166 struct v4l2_capability *cap) 167 { 168 struct saa7134_dev *dev = file->private_data; 169 170 strcpy(cap->driver, "saa7134"); 171 strlcpy(cap->card, saa7134_boards[dev->board].name, 172 sizeof(cap->card)); 173 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 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_vid_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 f->flags = V4L2_FMT_FLAG_COMPRESSED; 216 return 0; 217 } 218 219 static int empress_g_fmt_vid_cap(struct file *file, void *priv, 220 struct v4l2_format *f) 221 { 222 struct saa7134_dev *dev = file->private_data; 223 struct v4l2_mbus_framefmt mbus_fmt; 224 225 saa_call_all(dev, video, g_mbus_fmt, &mbus_fmt); 226 227 v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt); 228 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 229 f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets; 230 f->fmt.pix.bytesperline = 0; 231 f->fmt.pix.priv = 0; 232 233 return 0; 234 } 235 236 static int empress_s_fmt_vid_cap(struct file *file, void *priv, 237 struct v4l2_format *f) 238 { 239 struct saa7134_dev *dev = file->private_data; 240 struct v4l2_mbus_framefmt mbus_fmt; 241 242 v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED); 243 saa_call_all(dev, video, s_mbus_fmt, &mbus_fmt); 244 v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt); 245 246 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 247 f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets; 248 f->fmt.pix.bytesperline = 0; 249 f->fmt.pix.priv = 0; 250 251 return 0; 252 } 253 254 static int empress_try_fmt_vid_cap(struct file *file, void *priv, 255 struct v4l2_format *f) 256 { 257 struct saa7134_dev *dev = file->private_data; 258 struct v4l2_mbus_framefmt mbus_fmt; 259 260 v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED); 261 saa_call_all(dev, video, try_mbus_fmt, &mbus_fmt); 262 v4l2_fill_pix_format(&f->fmt.pix, &mbus_fmt); 263 264 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 265 f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets; 266 f->fmt.pix.bytesperline = 0; 267 f->fmt.pix.priv = 0; 268 269 return 0; 270 } 271 272 static int empress_reqbufs(struct file *file, void *priv, 273 struct v4l2_requestbuffers *p) 274 { 275 struct saa7134_dev *dev = file->private_data; 276 277 return videobuf_reqbufs(&dev->empress_tsq, p); 278 } 279 280 static int empress_querybuf(struct file *file, void *priv, 281 struct v4l2_buffer *b) 282 { 283 struct saa7134_dev *dev = file->private_data; 284 285 return videobuf_querybuf(&dev->empress_tsq, b); 286 } 287 288 static int empress_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 289 { 290 struct saa7134_dev *dev = file->private_data; 291 292 return videobuf_qbuf(&dev->empress_tsq, b); 293 } 294 295 static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 296 { 297 struct saa7134_dev *dev = file->private_data; 298 299 return videobuf_dqbuf(&dev->empress_tsq, b, 300 file->f_flags & O_NONBLOCK); 301 } 302 303 static int empress_streamon(struct file *file, void *priv, 304 enum v4l2_buf_type type) 305 { 306 struct saa7134_dev *dev = file->private_data; 307 308 return videobuf_streamon(&dev->empress_tsq); 309 } 310 311 static int empress_streamoff(struct file *file, void *priv, 312 enum v4l2_buf_type type) 313 { 314 struct saa7134_dev *dev = file->private_data; 315 316 return videobuf_streamoff(&dev->empress_tsq); 317 } 318 319 static int empress_s_ext_ctrls(struct file *file, void *priv, 320 struct v4l2_ext_controls *ctrls) 321 { 322 struct saa7134_dev *dev = file->private_data; 323 int err; 324 325 /* count == 0 is abused in saa6752hs.c, so that special 326 case is handled here explicitly. */ 327 if (ctrls->count == 0) 328 return 0; 329 330 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG) 331 return -EINVAL; 332 333 err = saa_call_empress(dev, core, s_ext_ctrls, ctrls); 334 ts_init_encoder(dev); 335 336 return err; 337 } 338 339 static int empress_g_ext_ctrls(struct file *file, void *priv, 340 struct v4l2_ext_controls *ctrls) 341 { 342 struct saa7134_dev *dev = file->private_data; 343 344 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG) 345 return -EINVAL; 346 return saa_call_empress(dev, core, g_ext_ctrls, ctrls); 347 } 348 349 static int empress_g_ctrl(struct file *file, void *priv, 350 struct v4l2_control *c) 351 { 352 struct saa7134_dev *dev = file->private_data; 353 354 return saa7134_g_ctrl_internal(dev, NULL, c); 355 } 356 357 static int empress_s_ctrl(struct file *file, void *priv, 358 struct v4l2_control *c) 359 { 360 struct saa7134_dev *dev = file->private_data; 361 362 return saa7134_s_ctrl_internal(dev, NULL, c); 363 } 364 365 static int empress_queryctrl(struct file *file, void *priv, 366 struct v4l2_queryctrl *c) 367 { 368 /* Must be sorted from low to high control ID! */ 369 static const u32 user_ctrls[] = { 370 V4L2_CID_USER_CLASS, 371 V4L2_CID_BRIGHTNESS, 372 V4L2_CID_CONTRAST, 373 V4L2_CID_SATURATION, 374 V4L2_CID_HUE, 375 V4L2_CID_AUDIO_VOLUME, 376 V4L2_CID_AUDIO_MUTE, 377 V4L2_CID_HFLIP, 378 0 379 }; 380 381 /* Must be sorted from low to high control ID! */ 382 static const u32 mpeg_ctrls[] = { 383 V4L2_CID_MPEG_CLASS, 384 V4L2_CID_MPEG_STREAM_TYPE, 385 V4L2_CID_MPEG_STREAM_PID_PMT, 386 V4L2_CID_MPEG_STREAM_PID_AUDIO, 387 V4L2_CID_MPEG_STREAM_PID_VIDEO, 388 V4L2_CID_MPEG_STREAM_PID_PCR, 389 V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ, 390 V4L2_CID_MPEG_AUDIO_ENCODING, 391 V4L2_CID_MPEG_AUDIO_L2_BITRATE, 392 V4L2_CID_MPEG_VIDEO_ENCODING, 393 V4L2_CID_MPEG_VIDEO_ASPECT, 394 V4L2_CID_MPEG_VIDEO_BITRATE_MODE, 395 V4L2_CID_MPEG_VIDEO_BITRATE, 396 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK, 397 0 398 }; 399 static const u32 *ctrl_classes[] = { 400 user_ctrls, 401 mpeg_ctrls, 402 NULL 403 }; 404 struct saa7134_dev *dev = file->private_data; 405 406 c->id = v4l2_ctrl_next(ctrl_classes, c->id); 407 if (c->id == 0) 408 return -EINVAL; 409 if (c->id == V4L2_CID_USER_CLASS || c->id == V4L2_CID_MPEG_CLASS) 410 return v4l2_ctrl_query_fill(c, 0, 0, 0, 0); 411 if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG) 412 return saa7134_queryctrl(file, priv, c); 413 return saa_call_empress(dev, core, queryctrl, c); 414 } 415 416 static int empress_querymenu(struct file *file, void *priv, 417 struct v4l2_querymenu *c) 418 { 419 struct saa7134_dev *dev = file->private_data; 420 421 if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG) 422 return -EINVAL; 423 return saa_call_empress(dev, core, querymenu, c); 424 } 425 426 static int empress_s_std(struct file *file, void *priv, v4l2_std_id id) 427 { 428 struct saa7134_dev *dev = file->private_data; 429 430 return saa7134_s_std_internal(dev, NULL, id); 431 } 432 433 static int empress_g_std(struct file *file, void *priv, v4l2_std_id *id) 434 { 435 struct saa7134_dev *dev = file->private_data; 436 437 *id = dev->tvnorm->id; 438 return 0; 439 } 440 441 static const struct v4l2_file_operations ts_fops = 442 { 443 .owner = THIS_MODULE, 444 .open = ts_open, 445 .release = ts_release, 446 .read = ts_read, 447 .poll = ts_poll, 448 .mmap = ts_mmap, 449 .ioctl = video_ioctl2, 450 }; 451 452 static const struct v4l2_ioctl_ops ts_ioctl_ops = { 453 .vidioc_querycap = empress_querycap, 454 .vidioc_enum_fmt_vid_cap = empress_enum_fmt_vid_cap, 455 .vidioc_try_fmt_vid_cap = empress_try_fmt_vid_cap, 456 .vidioc_s_fmt_vid_cap = empress_s_fmt_vid_cap, 457 .vidioc_g_fmt_vid_cap = empress_g_fmt_vid_cap, 458 .vidioc_reqbufs = empress_reqbufs, 459 .vidioc_querybuf = empress_querybuf, 460 .vidioc_qbuf = empress_qbuf, 461 .vidioc_dqbuf = empress_dqbuf, 462 .vidioc_streamon = empress_streamon, 463 .vidioc_streamoff = empress_streamoff, 464 .vidioc_s_ext_ctrls = empress_s_ext_ctrls, 465 .vidioc_g_ext_ctrls = empress_g_ext_ctrls, 466 .vidioc_enum_input = empress_enum_input, 467 .vidioc_g_input = empress_g_input, 468 .vidioc_s_input = empress_s_input, 469 .vidioc_queryctrl = empress_queryctrl, 470 .vidioc_querymenu = empress_querymenu, 471 .vidioc_g_ctrl = empress_g_ctrl, 472 .vidioc_s_ctrl = empress_s_ctrl, 473 .vidioc_s_std = empress_s_std, 474 .vidioc_g_std = empress_g_std, 475 }; 476 477 /* ----------------------------------------------------------- */ 478 479 static struct video_device saa7134_empress_template = { 480 .name = "saa7134-empress", 481 .fops = &ts_fops, 482 .ioctl_ops = &ts_ioctl_ops, 483 484 .tvnorms = SAA7134_NORMS, 485 }; 486 487 static void empress_signal_update(struct work_struct *work) 488 { 489 struct saa7134_dev* dev = 490 container_of(work, struct saa7134_dev, empress_workqueue); 491 492 if (dev->nosignal) { 493 dprintk("no video signal\n"); 494 } else { 495 dprintk("video signal acquired\n"); 496 } 497 } 498 499 static void empress_signal_change(struct saa7134_dev *dev) 500 { 501 schedule_work(&dev->empress_workqueue); 502 } 503 504 505 static int empress_init(struct saa7134_dev *dev) 506 { 507 int err; 508 509 dprintk("%s: %s\n",dev->name,__func__); 510 dev->empress_dev = video_device_alloc(); 511 if (NULL == dev->empress_dev) 512 return -ENOMEM; 513 *(dev->empress_dev) = saa7134_empress_template; 514 dev->empress_dev->v4l2_dev = &dev->v4l2_dev; 515 dev->empress_dev->release = video_device_release; 516 snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name), 517 "%s empress (%s)", dev->name, 518 saa7134_boards[dev->board].name); 519 520 INIT_WORK(&dev->empress_workqueue, empress_signal_update); 521 522 video_set_drvdata(dev->empress_dev, dev); 523 err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER, 524 empress_nr[dev->nr]); 525 if (err < 0) { 526 printk(KERN_INFO "%s: can't register video device\n", 527 dev->name); 528 video_device_release(dev->empress_dev); 529 dev->empress_dev = NULL; 530 return err; 531 } 532 printk(KERN_INFO "%s: registered device %s [mpeg]\n", 533 dev->name, video_device_node_name(dev->empress_dev)); 534 535 videobuf_queue_sg_init(&dev->empress_tsq, &saa7134_ts_qops, 536 &dev->pci->dev, &dev->slock, 537 V4L2_BUF_TYPE_VIDEO_CAPTURE, 538 V4L2_FIELD_ALTERNATE, 539 sizeof(struct saa7134_buf), 540 dev, NULL); 541 542 empress_signal_update(&dev->empress_workqueue); 543 return 0; 544 } 545 546 static int empress_fini(struct saa7134_dev *dev) 547 { 548 dprintk("%s: %s\n",dev->name,__func__); 549 550 if (NULL == dev->empress_dev) 551 return 0; 552 flush_work(&dev->empress_workqueue); 553 video_unregister_device(dev->empress_dev); 554 dev->empress_dev = NULL; 555 return 0; 556 } 557 558 static struct saa7134_mpeg_ops empress_ops = { 559 .type = SAA7134_MPEG_EMPRESS, 560 .init = empress_init, 561 .fini = empress_fini, 562 .signal_change = empress_signal_change, 563 }; 564 565 static int __init empress_register(void) 566 { 567 return saa7134_ts_register(&empress_ops); 568 } 569 570 static void __exit empress_unregister(void) 571 { 572 saa7134_ts_unregister(&empress_ops); 573 } 574 575 module_init(empress_register); 576 module_exit(empress_unregister); 577 578 /* ----------------------------------------------------------- */ 579 /* 580 * Local variables: 581 * c-basic-offset: 8 582 * End: 583 */ 584