drivers/media/video/saa7134/saa7134-empress.c

   1 /*
   2  * $Id: saa7134-empress.c,v 1.3 2004/11/07 13:17:15 kraxel Exp $
   3  *
   4  * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/list.h>
  23 #include <linux/module.h>
  24 #include <linux/kernel.h>
  25 #include <linux/slab.h>
  26 #include <linux/delay.h>
  27
  28 #include "saa7134-reg.h"
  29 #include "saa7134.h"
  30
  31 #include <media/saa6752hs.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 module_param_array(empress_nr, int, NULL, 0444);
  40 MODULE_PARM_DESC(empress_nr,"ts device number");
  41
  42 static unsigned int debug = 0;
  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         saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
  54         msleep(10);
  55         saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
  56         msleep(100);
  57 }
  58
  59 static int ts_init_encoder(struct saa7134_dev* dev, void* arg)
  60 {
  61         ts_reset_encoder(dev);
  62         saa7134_i2c_call_clients(dev, MPEG_SETPARAMS, arg);
  63         return 0;
  64 }
  65
  66 /* ------------------------------------------------------------------ */
  67
  68 static int ts_open(struct inode *inode, struct file *file)
  69 {
  70         int minor = iminor(inode);
  71         struct saa7134_dev *h,*dev = NULL;
  72         struct list_head *list;
  73         int err;
  74
  75         list_for_each(list,&saa7134_devlist) {
  76                 h = list_entry(list, struct saa7134_dev, devlist);
  77                 if (h->empress_dev && h->empress_dev->minor == minor)
  78                         dev = h;
  79         }
  80         if (NULL == dev)
  81                 return -ENODEV;
  82
  83         dprintk("open minor=%d\n",minor);
  84         down(&dev->empress_tsq.lock);
  85         err = -EBUSY;
  86         if (dev->empress_users)
  87                 goto done;
  88
  89         dev->empress_users++;
  90         file->private_data = dev;
  91         ts_init_encoder(dev, NULL);
  92         err = 0;
  93
  94  done:
  95         up(&dev->empress_tsq.lock);
  96         return err;
  97 }
  98
  99 static int ts_release(struct inode *inode, struct file *file)
 100 {
 101         struct saa7134_dev *dev = file->private_data;
 102
 103         if (dev->empress_tsq.streaming)
 104                 videobuf_streamoff(&dev->empress_tsq);
 105         down(&dev->empress_tsq.lock);
 106         if (dev->empress_tsq.reading)
 107                 videobuf_read_stop(&dev->empress_tsq);
 108         dev->empress_users--;
 109
 110         /* stop the encoder */
 111         ts_reset_encoder(dev);
 112
 113         up(&dev->empress_tsq.lock);
 114         return 0;
 115 }
 116
 117 static ssize_t
 118 ts_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 119 {
 120         struct saa7134_dev *dev = file->private_data;
 121
 122         return videobuf_read_stream(&dev->empress_tsq,
 123                                     data, count, ppos, 0,
 124                                     file->f_flags & O_NONBLOCK);
 125 }
 126
 127 static unsigned int
 128 ts_poll(struct file *file, struct poll_table_struct *wait)
 129 {
 130         struct saa7134_dev *dev = file->private_data;
 131
 132         return videobuf_poll_stream(file, &dev->empress_tsq, wait);
 133 }
 134
 135
 136 static int
 137 ts_mmap(struct file *file, struct vm_area_struct * vma)
 138 {
 139         struct saa7134_dev *dev = file->private_data;
 140
 141         return videobuf_mmap_mapper(&dev->empress_tsq, vma);
 142 }
 143
 144 /*
 145  * This function is _not_ called directly, but from
 146  * video_generic_ioctl (and maybe others).  userspace
 147  * copying is done already, arg is a kernel pointer.
 148  */
 149 static int ts_do_ioctl(struct inode *inode, struct file *file,
 150                        unsigned int cmd, void *arg)
 151 {
 152         struct saa7134_dev *dev = file->private_data;
 153
 154         if (debug > 1)
 155                 saa7134_print_ioctl(dev->name,cmd);
 156         switch (cmd) {
 157         case VIDIOC_QUERYCAP:
 158         {
 159                 struct v4l2_capability *cap = arg;
 160
 161                 memset(cap,0,sizeof(*cap));
 162                 strcpy(cap->driver, "saa7134");
 163                 strlcpy(cap->card, saa7134_boards[dev->board].name,
 164                         sizeof(cap->card));
 165                 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
 166                 cap->version = SAA7134_VERSION_CODE;
 167                 cap->capabilities =
 168                         V4L2_CAP_VIDEO_CAPTURE |
 169                         V4L2_CAP_READWRITE |
 170                         V4L2_CAP_STREAMING;
 171                 return 0;
 172         }
 173
 174         /* --- input switching --------------------------------------- */
 175         case VIDIOC_ENUMINPUT:
 176         {
 177                 struct v4l2_input *i = arg;
 178
 179                 if (i->index != 0)
 180                         return -EINVAL;
 181                 i->type = V4L2_INPUT_TYPE_CAMERA;
 182                 strcpy(i->name,"CCIR656");
 183                 return 0;
 184         }
 185         case VIDIOC_G_INPUT:
 186         {
 187                 int *i = arg;
 188                 *i = 0;
 189                 return 0;
 190         }
 191         case VIDIOC_S_INPUT:
 192         {
 193                 int *i = arg;
 194
 195                 if (*i != 0)
 196                         return -EINVAL;
 197                 return 0;
 198         }
 199         /* --- capture ioctls ---------------------------------------- */
 200
 201         case VIDIOC_ENUM_FMT:
 202         {
 203                 struct v4l2_fmtdesc *f = arg;
 204                 int index;
 205
 206                 index = f->index;
 207                 if (index != 0)
 208                         return -EINVAL;
 209
 210                 memset(f,0,sizeof(*f));
 211                 f->index = index;
 212                 strlcpy(f->description, "MPEG TS", sizeof(f->description));
 213                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 214                 f->pixelformat = V4L2_PIX_FMT_MPEG;
 215                 return 0;
 216         }
 217
 218         case VIDIOC_G_FMT:
 219         {
 220                 struct v4l2_format *f = arg;
 221
 222                 memset(f,0,sizeof(*f));
 223                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 224
 225                 /* FIXME: translate subsampling type EMPRESS into
 226                  *        width/height: */
 227                 f->fmt.pix.width        = 720; /* D1 */
 228                 f->fmt.pix.height       = 576;
 229                 f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 230                 f->fmt.pix.sizeimage    = TS_PACKET_SIZE * dev->ts.nr_packets;
 231                 return 0;
 232         }
 233
 234         case VIDIOC_S_FMT:
 235         {
 236                 struct v4l2_format *f = arg;
 237
 238                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 239                     return -EINVAL;
 240
 241                 /*
 242                   FIXME: translate and round width/height into EMPRESS
 243                   subsample type:
 244
 245                           type  |   PAL   |  NTSC
 246                         ---------------------------
 247                           SIF   | 352x288 | 352x240
 248                          1/2 D1 | 352x576 | 352x480
 249                          2/3 D1 | 480x576 | 480x480
 250                           D1    | 720x576 | 720x480
 251                 */
 252
 253                 f->fmt.pix.width        = 720; /* D1 */
 254                 f->fmt.pix.height       = 576;
 255                 f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 256                 f->fmt.pix.sizeimage    = TS_PACKET_SIZE* dev->ts.nr_packets;
 257                 return 0;
 258         }
 259
 260         case VIDIOC_REQBUFS:
 261                 return videobuf_reqbufs(&dev->empress_tsq,arg);
 262
 263         case VIDIOC_QUERYBUF:
 264                 return videobuf_querybuf(&dev->empress_tsq,arg);
 265
 266         case VIDIOC_QBUF:
 267                 return videobuf_qbuf(&dev->empress_tsq,arg);
 268
 269         case VIDIOC_DQBUF:
 270                 return videobuf_dqbuf(&dev->empress_tsq,arg,
 271                                       file->f_flags & O_NONBLOCK);
 272
 273         case VIDIOC_STREAMON:
 274                 return videobuf_streamon(&dev->empress_tsq);
 275
 276         case VIDIOC_STREAMOFF:
 277                 return videobuf_streamoff(&dev->empress_tsq);
 278
 279         case VIDIOC_QUERYCTRL:
 280         case VIDIOC_G_CTRL:
 281         case VIDIOC_S_CTRL:
 282                 return saa7134_common_ioctl(dev, cmd, arg);
 283
 284         case MPEG_SETPARAMS:
 285                 return ts_init_encoder(dev, arg);
 286
 287         default:
 288                 return -ENOIOCTLCMD;
 289         }
 290         return 0;
 291 }
 292
 293 static int ts_ioctl(struct inode *inode, struct file *file,
 294                      unsigned int cmd, unsigned long arg)
 295 {
 296         return video_usercopy(inode, file, cmd, arg, ts_do_ioctl);
 297 }
 298
 299 static struct file_operations ts_fops =
 300 {
 301         .owner    = THIS_MODULE,
 302         .open     = ts_open,
 303         .release  = ts_release,
 304         .read     = ts_read,
 305         .poll     = ts_poll,
 306         .mmap     = ts_mmap,
 307         .ioctl    = ts_ioctl,
 308         .llseek   = no_llseek,
 309 };
 310
 311 /* ----------------------------------------------------------- */
 312
 313 static struct video_device saa7134_empress_template =
 314 {
 315         .name          = "saa7134-empress",
 316         .type          = 0 /* FIXME */,
 317         .type2         = 0 /* FIXME */,
 318         .hardware      = 0,
 319         .fops          = &ts_fops,
 320         .minor         = -1,
 321 };
 322
 323 static int empress_init(struct saa7134_dev *dev)
 324 {
 325         int err;
 326
 327         dprintk("%s: %s\n",dev->name,__FUNCTION__);
 328         dev->empress_dev = video_device_alloc();
 329         if (NULL == dev->empress_dev)
 330                 return -ENOMEM;
 331         *(dev->empress_dev) = saa7134_empress_template;
 332         dev->empress_dev->dev     = &dev->pci->dev;
 333         dev->empress_dev->release = video_device_release;
 334         snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name),
 335                  "%s empress (%s)", dev->name,
 336                  saa7134_boards[dev->board].name);
 337
 338         err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,
 339                                     empress_nr[dev->nr]);
 340         if (err < 0) {
 341                 printk(KERN_INFO "%s: can't register video device\n",
 342                        dev->name);
 343                 video_device_release(dev->empress_dev);
 344                 dev->empress_dev = NULL;
 345                 return err;
 346         }
 347         printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
 348                dev->name,dev->empress_dev->minor & 0x1f);
 349
 350         videobuf_queue_init(&dev->empress_tsq, &saa7134_ts_qops,
 351                             dev->pci, &dev->slock,
 352                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
 353                             V4L2_FIELD_ALTERNATE,
 354                             sizeof(struct saa7134_buf),
 355                             dev);
 356         return 0;
 357 }
 358
 359 static int empress_fini(struct saa7134_dev *dev)
 360 {
 361         dprintk("%s: %s\n",dev->name,__FUNCTION__);
 362
 363         if (NULL == dev->empress_dev)
 364                 return 0;
 365         video_unregister_device(dev->empress_dev);
 366         dev->empress_dev = NULL;
 367         return 0;
 368 }
 369
 370 static struct saa7134_mpeg_ops empress_ops = {
 371         .type          = SAA7134_MPEG_EMPRESS,
 372         .init          = empress_init,
 373         .fini          = empress_fini,
 374 };
 375
 376 static int __init empress_register(void)
 377 {
 378         return saa7134_ts_register(&empress_ops);
 379 }
 380
 381 static void __exit empress_unregister(void)
 382 {
 383         saa7134_ts_unregister(&empress_ops);
 384 }
 385
 386 module_init(empress_register);
 387 module_exit(empress_unregister);
 388
 389 /* ----------------------------------------------------------- */
 390 /*
 391  * Local variables:
 392  * c-basic-offset: 8
 393  * End:
 394  */