saa7134-empress.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594
  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. #include <linux/init.h>
  20. #include <linux/list.h>
  21. #include <linux/module.h>
  22. #include <linux/kernel.h>
  23. #include <linux/slab.h>
  24. #include <linux/smp_lock.h>
  25. #include <linux/delay.h>
  26. #include "saa7134-reg.h"
  27. #include "saa7134.h"
  28. #include <media/saa6752hs.h>
  29. #include <media/v4l2-common.h>
  30. #include <media/v4l2-chip-ident.h>
  31. /* ------------------------------------------------------------------ */
  32. MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
  33. MODULE_LICENSE("GPL");
  34. static unsigned int empress_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
  35. module_param_array(empress_nr, int, NULL, 0444);
  36. MODULE_PARM_DESC(empress_nr,"ts device number");
  37. static unsigned int debug;
  38. module_param(debug, int, 0644);
  39. MODULE_PARM_DESC(debug,"enable debug messages");
  40. #define dprintk(fmt, arg...) if (debug) \
  41. printk(KERN_DEBUG "%s/empress: " fmt, dev->name , ## arg)
  42. /* ------------------------------------------------------------------ */
  43. static void ts_reset_encoder(struct saa7134_dev* dev)
  44. {
  45. if (!dev->empress_started)
  46. return;
  47. saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
  48. msleep(10);
  49. saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
  50. msleep(100);
  51. dev->empress_started = 0;
  52. }
  53. static int ts_init_encoder(struct saa7134_dev* dev)
  54. {
  55. u32 leading_null_bytes = 0;
  56. /* If more cards start to need this, then this
  57. should probably be added to the card definitions. */
  58. switch (dev->board) {
  59. case SAA7134_BOARD_BEHOLD_M6:
  60. case SAA7134_BOARD_BEHOLD_M63:
  61. case SAA7134_BOARD_BEHOLD_M6_EXTRA:
  62. leading_null_bytes = 1;
  63. break;
  64. }
  65. ts_reset_encoder(dev);
  66. saa_call_all(dev, core, init, leading_null_bytes);
  67. dev->empress_started = 1;
  68. return 0;
  69. }
  70. /* ------------------------------------------------------------------ */
  71. static int ts_open(struct file *file)
  72. {
  73. int minor = video_devdata(file)->minor;
  74. struct saa7134_dev *dev;
  75. int err;
  76. lock_kernel();
  77. list_for_each_entry(dev, &saa7134_devlist, devlist)
  78. if (dev->empress_dev && dev->empress_dev->minor == minor)
  79. goto found;
  80. unlock_kernel();
  81. return -ENODEV;
  82. found:
  83. dprintk("open minor=%d\n",minor);
  84. err = -EBUSY;
  85. if (!mutex_trylock(&dev->empress_tsq.vb_lock))
  86. goto done;
  87. if (atomic_read(&dev->empress_users))
  88. goto done_up;
  89. /* Unmute audio */
  90. saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
  91. saa_readb(SAA7134_AUDIO_MUTE_CTRL) & ~(1 << 6));
  92. atomic_inc(&dev->empress_users);
  93. file->private_data = dev;
  94. err = 0;
  95. done_up:
  96. mutex_unlock(&dev->empress_tsq.vb_lock);
  97. done:
  98. unlock_kernel();
  99. return err;
  100. }
  101. static int ts_release(struct file *file)
  102. {
  103. struct saa7134_dev *dev = file->private_data;
  104. videobuf_stop(&dev->empress_tsq);
  105. videobuf_mmap_free(&dev->empress_tsq);
  106. /* stop the encoder */
  107. ts_reset_encoder(dev);
  108. /* Mute audio */
  109. saa_writeb(SAA7134_AUDIO_MUTE_CTRL,
  110. saa_readb(SAA7134_AUDIO_MUTE_CTRL) | (1 << 6));
  111. atomic_dec(&dev->empress_users);
  112. return 0;
  113. }
  114. static ssize_t
  115. ts_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
  116. {
  117. struct saa7134_dev *dev = file->private_data;
  118. if (!dev->empress_started)
  119. ts_init_encoder(dev);
  120. return videobuf_read_stream(&dev->empress_tsq,
  121. data, count, ppos, 0,
  122. file->f_flags & O_NONBLOCK);
  123. }
  124. static unsigned int
  125. ts_poll(struct file *file, struct poll_table_struct *wait)
  126. {
  127. struct saa7134_dev *dev = file->private_data;
  128. return videobuf_poll_stream(file, &dev->empress_tsq, wait);
  129. }
  130. static int
  131. ts_mmap(struct file *file, struct vm_area_struct * vma)
  132. {
  133. struct saa7134_dev *dev = file->private_data;
  134. return videobuf_mmap_mapper(&dev->empress_tsq, vma);
  135. }
  136. /*
  137. * This function is _not_ called directly, but from
  138. * video_generic_ioctl (and maybe others). userspace
  139. * copying is done already, arg is a kernel pointer.
  140. */
  141. static int empress_querycap(struct file *file, void *priv,
  142. struct v4l2_capability *cap)
  143. {
  144. struct saa7134_dev *dev = file->private_data;
  145. strcpy(cap->driver, "saa7134");
  146. strlcpy(cap->card, saa7134_boards[dev->board].name,
  147. sizeof(cap->card));
  148. sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
  149. cap->version = SAA7134_VERSION_CODE;
  150. cap->capabilities =
  151. V4L2_CAP_VIDEO_CAPTURE |
  152. V4L2_CAP_READWRITE |
  153. V4L2_CAP_STREAMING;
  154. return 0;
  155. }
  156. static int empress_enum_input(struct file *file, void *priv,
  157. struct v4l2_input *i)
  158. {
  159. if (i->index != 0)
  160. return -EINVAL;
  161. i->type = V4L2_INPUT_TYPE_CAMERA;
  162. strcpy(i->name, "CCIR656");
  163. return 0;
  164. }
  165. static int empress_g_input(struct file *file, void *priv, unsigned int *i)
  166. {
  167. *i = 0;
  168. return 0;
  169. }
  170. static int empress_s_input(struct file *file, void *priv, unsigned int i)
  171. {
  172. if (i != 0)
  173. return -EINVAL;
  174. return 0;
  175. }
  176. static int empress_enum_fmt_vid_cap(struct file *file, void *priv,
  177. struct v4l2_fmtdesc *f)
  178. {
  179. if (f->index != 0)
  180. return -EINVAL;
  181. strlcpy(f->description, "MPEG TS", sizeof(f->description));
  182. f->pixelformat = V4L2_PIX_FMT_MPEG;
  183. return 0;
  184. }
  185. static int empress_g_fmt_vid_cap(struct file *file, void *priv,
  186. struct v4l2_format *f)
  187. {
  188. struct saa7134_dev *dev = file->private_data;
  189. saa_call_all(dev, video, g_fmt, f);
  190. f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
  191. f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets;
  192. return 0;
  193. }
  194. static int empress_s_fmt_vid_cap(struct file *file, void *priv,
  195. struct v4l2_format *f)
  196. {
  197. struct saa7134_dev *dev = file->private_data;
  198. saa_call_all(dev, video, s_fmt, f);
  199. f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
  200. f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets;
  201. return 0;
  202. }
  203. static int empress_try_fmt_vid_cap(struct file *file, void *priv,
  204. struct v4l2_format *f)
  205. {
  206. struct saa7134_dev *dev = file->private_data;
  207. f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
  208. f->fmt.pix.sizeimage = TS_PACKET_SIZE * dev->ts.nr_packets;
  209. return 0;
  210. }
  211. static int empress_reqbufs(struct file *file, void *priv,
  212. struct v4l2_requestbuffers *p)
  213. {
  214. struct saa7134_dev *dev = file->private_data;
  215. return videobuf_reqbufs(&dev->empress_tsq, p);
  216. }
  217. static int empress_querybuf(struct file *file, void *priv,
  218. struct v4l2_buffer *b)
  219. {
  220. struct saa7134_dev *dev = file->private_data;
  221. return videobuf_querybuf(&dev->empress_tsq, b);
  222. }
  223. static int empress_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
  224. {
  225. struct saa7134_dev *dev = file->private_data;
  226. return videobuf_qbuf(&dev->empress_tsq, b);
  227. }
  228. static int empress_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
  229. {
  230. struct saa7134_dev *dev = file->private_data;
  231. return videobuf_dqbuf(&dev->empress_tsq, b,
  232. file->f_flags & O_NONBLOCK);
  233. }
  234. static int empress_streamon(struct file *file, void *priv,
  235. enum v4l2_buf_type type)
  236. {
  237. struct saa7134_dev *dev = file->private_data;
  238. return videobuf_streamon(&dev->empress_tsq);
  239. }
  240. static int empress_streamoff(struct file *file, void *priv,
  241. enum v4l2_buf_type type)
  242. {
  243. struct saa7134_dev *dev = file->private_data;
  244. return videobuf_streamoff(&dev->empress_tsq);
  245. }
  246. static int empress_s_ext_ctrls(struct file *file, void *priv,
  247. struct v4l2_ext_controls *ctrls)
  248. {
  249. struct saa7134_dev *dev = file->private_data;
  250. int err;
  251. /* count == 0 is abused in saa6752hs.c, so that special
  252. case is handled here explicitly. */
  253. if (ctrls->count == 0)
  254. return 0;
  255. if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
  256. return -EINVAL;
  257. err = saa_call_empress(dev, core, s_ext_ctrls, ctrls);
  258. ts_init_encoder(dev);
  259. return err;
  260. }
  261. static int empress_g_ext_ctrls(struct file *file, void *priv,
  262. struct v4l2_ext_controls *ctrls)
  263. {
  264. struct saa7134_dev *dev = file->private_data;
  265. if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
  266. return -EINVAL;
  267. return saa_call_empress(dev, core, g_ext_ctrls, ctrls);
  268. }
  269. static int empress_g_ctrl(struct file *file, void *priv,
  270. struct v4l2_control *c)
  271. {
  272. struct saa7134_dev *dev = file->private_data;
  273. return saa7134_g_ctrl_internal(dev, NULL, c);
  274. }
  275. static int empress_s_ctrl(struct file *file, void *priv,
  276. struct v4l2_control *c)
  277. {
  278. struct saa7134_dev *dev = file->private_data;
  279. return saa7134_s_ctrl_internal(dev, NULL, c);
  280. }
  281. static int empress_queryctrl(struct file *file, void *priv,
  282. struct v4l2_queryctrl *c)
  283. {
  284. /* Must be sorted from low to high control ID! */
  285. static const u32 user_ctrls[] = {
  286. V4L2_CID_USER_CLASS,
  287. V4L2_CID_BRIGHTNESS,
  288. V4L2_CID_CONTRAST,
  289. V4L2_CID_SATURATION,
  290. V4L2_CID_HUE,
  291. V4L2_CID_AUDIO_VOLUME,
  292. V4L2_CID_AUDIO_MUTE,
  293. V4L2_CID_HFLIP,
  294. 0
  295. };
  296. /* Must be sorted from low to high control ID! */
  297. static const u32 mpeg_ctrls[] = {
  298. V4L2_CID_MPEG_CLASS,
  299. V4L2_CID_MPEG_STREAM_TYPE,
  300. V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
  301. V4L2_CID_MPEG_AUDIO_ENCODING,
  302. V4L2_CID_MPEG_AUDIO_L2_BITRATE,
  303. V4L2_CID_MPEG_VIDEO_ENCODING,
  304. V4L2_CID_MPEG_VIDEO_ASPECT,
  305. V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
  306. V4L2_CID_MPEG_VIDEO_BITRATE,
  307. V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
  308. 0
  309. };
  310. static const u32 *ctrl_classes[] = {
  311. user_ctrls,
  312. mpeg_ctrls,
  313. NULL
  314. };
  315. struct saa7134_dev *dev = file->private_data;
  316. c->id = v4l2_ctrl_next(ctrl_classes, c->id);
  317. if (c->id == 0)
  318. return -EINVAL;
  319. if (c->id == V4L2_CID_USER_CLASS || c->id == V4L2_CID_MPEG_CLASS)
  320. return v4l2_ctrl_query_fill(c, 0, 0, 0, 0);
  321. if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
  322. return saa7134_queryctrl(file, priv, c);
  323. return saa_call_empress(dev, core, queryctrl, c);
  324. }
  325. static int empress_querymenu(struct file *file, void *priv,
  326. struct v4l2_querymenu *c)
  327. {
  328. struct saa7134_dev *dev = file->private_data;
  329. if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
  330. return -EINVAL;
  331. return saa_call_empress(dev, core, querymenu, c);
  332. }
  333. static int empress_g_chip_ident(struct file *file, void *fh,
  334. struct v4l2_dbg_chip_ident *chip)
  335. {
  336. struct saa7134_dev *dev = file->private_data;
  337. chip->ident = V4L2_IDENT_NONE;
  338. chip->revision = 0;
  339. if (chip->match.type == V4L2_CHIP_MATCH_I2C_DRIVER &&
  340. !strcmp(chip->match.name, "saa6752hs"))
  341. return saa_call_empress(dev, core, g_chip_ident, chip);
  342. if (chip->match.type == V4L2_CHIP_MATCH_I2C_ADDR)
  343. return saa_call_empress(dev, core, g_chip_ident, chip);
  344. return -EINVAL;
  345. }
  346. static int empress_s_std(struct file *file, void *priv, v4l2_std_id *id)
  347. {
  348. struct saa7134_dev *dev = file->private_data;
  349. return saa7134_s_std_internal(dev, NULL, id);
  350. }
  351. static int empress_g_std(struct file *file, void *priv, v4l2_std_id *id)
  352. {
  353. struct saa7134_dev *dev = file->private_data;
  354. *id = dev->tvnorm->id;
  355. return 0;
  356. }
  357. static const struct v4l2_file_operations ts_fops =
  358. {
  359. .owner = THIS_MODULE,
  360. .open = ts_open,
  361. .release = ts_release,
  362. .read = ts_read,
  363. .poll = ts_poll,
  364. .mmap = ts_mmap,
  365. .ioctl = video_ioctl2,
  366. };
  367. static const struct v4l2_ioctl_ops ts_ioctl_ops = {
  368. .vidioc_querycap = empress_querycap,
  369. .vidioc_enum_fmt_vid_cap = empress_enum_fmt_vid_cap,
  370. .vidioc_try_fmt_vid_cap = empress_try_fmt_vid_cap,
  371. .vidioc_s_fmt_vid_cap = empress_s_fmt_vid_cap,
  372. .vidioc_g_fmt_vid_cap = empress_g_fmt_vid_cap,
  373. .vidioc_reqbufs = empress_reqbufs,
  374. .vidioc_querybuf = empress_querybuf,
  375. .vidioc_qbuf = empress_qbuf,
  376. .vidioc_dqbuf = empress_dqbuf,
  377. .vidioc_streamon = empress_streamon,
  378. .vidioc_streamoff = empress_streamoff,
  379. .vidioc_s_ext_ctrls = empress_s_ext_ctrls,
  380. .vidioc_g_ext_ctrls = empress_g_ext_ctrls,
  381. .vidioc_enum_input = empress_enum_input,
  382. .vidioc_g_input = empress_g_input,
  383. .vidioc_s_input = empress_s_input,
  384. .vidioc_queryctrl = empress_queryctrl,
  385. .vidioc_querymenu = empress_querymenu,
  386. .vidioc_g_ctrl = empress_g_ctrl,
  387. .vidioc_s_ctrl = empress_s_ctrl,
  388. .vidioc_g_chip_ident = empress_g_chip_ident,
  389. .vidioc_s_std = empress_s_std,
  390. .vidioc_g_std = empress_g_std,
  391. };
  392. /* ----------------------------------------------------------- */
  393. static struct video_device saa7134_empress_template = {
  394. .name = "saa7134-empress",
  395. .fops = &ts_fops,
  396. .minor = -1,
  397. .ioctl_ops = &ts_ioctl_ops,
  398. .tvnorms = SAA7134_NORMS,
  399. .current_norm = V4L2_STD_PAL,
  400. };
  401. static void empress_signal_update(struct work_struct *work)
  402. {
  403. struct saa7134_dev* dev =
  404. container_of(work, struct saa7134_dev, empress_workqueue);
  405. if (dev->nosignal) {
  406. dprintk("no video signal\n");
  407. } else {
  408. dprintk("video signal acquired\n");
  409. }
  410. }
  411. static void empress_signal_change(struct saa7134_dev *dev)
  412. {
  413. schedule_work(&dev->empress_workqueue);
  414. }
  415. static int empress_init(struct saa7134_dev *dev)
  416. {
  417. int err;
  418. dprintk("%s: %s\n",dev->name,__func__);
  419. dev->empress_dev = video_device_alloc();
  420. if (NULL == dev->empress_dev)
  421. return -ENOMEM;
  422. *(dev->empress_dev) = saa7134_empress_template;
  423. dev->empress_dev->parent = &dev->pci->dev;
  424. dev->empress_dev->release = video_device_release;
  425. snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name),
  426. "%s empress (%s)", dev->name,
  427. saa7134_boards[dev->board].name);
  428. INIT_WORK(&dev->empress_workqueue, empress_signal_update);
  429. err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,
  430. empress_nr[dev->nr]);
  431. if (err < 0) {
  432. printk(KERN_INFO "%s: can't register video device\n",
  433. dev->name);
  434. video_device_release(dev->empress_dev);
  435. dev->empress_dev = NULL;
  436. return err;
  437. }
  438. printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
  439. dev->name, dev->empress_dev->num);
  440. videobuf_queue_sg_init(&dev->empress_tsq, &saa7134_ts_qops,
  441. &dev->pci->dev, &dev->slock,
  442. V4L2_BUF_TYPE_VIDEO_CAPTURE,
  443. V4L2_FIELD_ALTERNATE,
  444. sizeof(struct saa7134_buf),
  445. dev);
  446. empress_signal_update(&dev->empress_workqueue);
  447. return 0;
  448. }
  449. static int empress_fini(struct saa7134_dev *dev)
  450. {
  451. dprintk("%s: %s\n",dev->name,__func__);
  452. if (NULL == dev->empress_dev)
  453. return 0;
  454. flush_scheduled_work();
  455. video_unregister_device(dev->empress_dev);
  456. dev->empress_dev = NULL;
  457. return 0;
  458. }
  459. static struct saa7134_mpeg_ops empress_ops = {
  460. .type = SAA7134_MPEG_EMPRESS,
  461. .init = empress_init,
  462. .fini = empress_fini,
  463. .signal_change = empress_signal_change,
  464. };
  465. static int __init empress_register(void)
  466. {
  467. return saa7134_ts_register(&empress_ops);
  468. }
  469. static void __exit empress_unregister(void)
  470. {
  471. saa7134_ts_unregister(&empress_ops);
  472. }
  473. module_init(empress_register);
  474. module_exit(empress_unregister);
  475. /* ----------------------------------------------------------- */
  476. /*
  477. * Local variables:
  478. * c-basic-offset: 8
  479. * End:
  480. */