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

   1 /*
   2  * device driver for philips saa7134 based TV cards
   3  * video4linux video interface
   4  *
   5  * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/init.h>
  23 #include <linux/list.h>
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/slab.h>
  27
  28 #include "saa7134-reg.h"
  29 #include "saa7134.h"
  30
  31 /* ------------------------------------------------------------------ */
  32
  33 static unsigned int ts_debug  = 0;
  34 MODULE_PARM(ts_debug,"i");
  35 MODULE_PARM_DESC(ts_debug,"enable debug messages [ts]");
  36
  37 static unsigned int tsbufs = 4;
  38 MODULE_PARM(tsbufs,"i");
  39 MODULE_PARM_DESC(tsbufs,"number of ts buffers, range 2-32");
  40
  41 #define TS_PACKET_SIZE 188 /* TS packets 188 bytes */
  42 #define TS_NR_PACKETS 312
  43
  44 #define dprintk(fmt, arg...)    if (ts_debug) \
  45         printk(KERN_DEBUG "%s/ts: " fmt, dev->name, ## arg)
  46
  47 /* ------------------------------------------------------------------ */
  48
  49 static int buffer_activate(struct saa7134_dev *dev,
  50                            struct saa7134_buf *buf,
  51                            struct saa7134_buf *next)
  52 {
  53         u32 control;
  54
  55         dprintk("buffer_activate [%p]",buf);
  56         buf->vb.state = STATE_ACTIVE;
  57         buf->top_seen = 0;
  58
  59         /* dma: setup channel 5 (= TS) */
  60         control = SAA7134_RS_CONTROL_BURST_16 |
  61                 SAA7134_RS_CONTROL_ME |
  62                 (buf->pt->dma >> 12);
  63
  64         if (NULL == next)
  65                 next = buf;
  66         if (V4L2_FIELD_TOP == buf->vb.field) {
  67                 dprintk("- [top]     buf=%p next=%p\n",buf,next);
  68                 saa_writel(SAA7134_RS_BA1(5),saa7134_buffer_base(buf));
  69                 saa_writel(SAA7134_RS_BA2(5),saa7134_buffer_base(next));
  70         } else {
  71                 dprintk("- [bottom]  buf=%p next=%p\n",buf,next);
  72                 saa_writel(SAA7134_RS_BA1(5),saa7134_buffer_base(next));
  73                 saa_writel(SAA7134_RS_BA2(5),saa7134_buffer_base(buf));
  74         }
  75         saa_writel(SAA7134_RS_PITCH(5),TS_PACKET_SIZE);
  76         saa_writel(SAA7134_RS_CONTROL(5),control);
  77
  78         /* start DMA */
  79         saa7134_set_dmabits(dev);
  80
  81         mod_timer(&dev->ts_q.timeout, jiffies+BUFFER_TIMEOUT);
  82         return 0;
  83 }
  84
  85 static int buffer_prepare(struct file *file, struct videobuf_buffer *vb,
  86                           enum v4l2_field field)
  87 {
  88         struct saa7134_dev *dev = file->private_data;
  89         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
  90         unsigned int lines, llength, size;
  91         int err;
  92
  93         dprintk("buffer_prepare [%p,%s]\n",buf,v4l2_field_names[field]);
  94
  95         llength = TS_PACKET_SIZE;
  96         lines = TS_NR_PACKETS;
  97
  98         size = lines * llength;
  99         if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
 100                 return -EINVAL;
 101
 102         if (buf->vb.size != size) {
 103                 saa7134_dma_free(dev,buf);
 104         }
 105
 106         if (STATE_NEEDS_INIT == buf->vb.state) {
 107                 buf->vb.width  = llength;
 108                 buf->vb.height = lines;
 109                 buf->vb.size   = size;
 110                 buf->pt        = &dev->ts.pt_ts;
 111
 112                 err = videobuf_iolock(dev->pci,&buf->vb);
 113                 if (err)
 114                         goto oops;
 115                 err = saa7134_pgtable_build(dev->pci,buf->pt,
 116                                             buf->vb.dma.sglist,
 117                                             buf->vb.dma.sglen,
 118                                             saa7134_buffer_startpage(buf));
 119                 if (err)
 120                         goto oops;
 121         }
 122         buf->vb.state = STATE_PREPARED;
 123         buf->activate = buffer_activate;
 124         buf->vb.field = field;
 125         return 0;
 126
 127  oops:
 128         saa7134_dma_free(dev,buf);
 129         return err;
 130 }
 131
 132 static int
 133 buffer_setup(struct file *file, unsigned int *count, unsigned int *size)
 134 {
 135         *size = TS_PACKET_SIZE * TS_NR_PACKETS;
 136         if (0 == *count)
 137                 *count = tsbufs;
 138         *count = saa7134_buffer_count(*size,*count);
 139         return 0;
 140 }
 141
 142 static void buffer_queue(struct file *file, struct videobuf_buffer *vb)
 143 {
 144         struct saa7134_dev *dev = file->private_data;
 145         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
 146
 147         saa7134_buffer_queue(dev,&dev->ts_q,buf);
 148 }
 149
 150 static void buffer_release(struct file *file, struct videobuf_buffer *vb)
 151 {
 152         struct saa7134_dev *dev = file->private_data;
 153         struct saa7134_buf *buf = (struct saa7134_buf *)vb;
 154
 155         saa7134_dma_free(dev,buf);
 156 }
 157
 158 static struct videobuf_queue_ops ts_qops = {
 159         .buf_setup    = buffer_setup,
 160         .buf_prepare  = buffer_prepare,
 161         .buf_queue    = buffer_queue,
 162         .buf_release  = buffer_release,
 163 };
 164
 165 /* ------------------------------------------------------------------ */
 166
 167 static int ts_open(struct inode *inode, struct file *file)
 168 {
 169         int minor = minor(inode->i_rdev);
 170         struct saa7134_dev *h,*dev = NULL;
 171         struct list_head *list;
 172         int err;
 173
 174         list_for_each(list,&saa7134_devlist) {
 175                 h = list_entry(list, struct saa7134_dev, devlist);
 176                 if (h->ts_dev.minor == minor)
 177                         dev = h;
 178         }
 179         if (NULL == dev)
 180                 return -ENODEV;
 181
 182         dprintk("open minor=%d\n",minor);
 183         down(&dev->ts.ts.lock);
 184         err = -EBUSY;
 185         if (dev->ts.users)
 186                 goto done;
 187
 188         dev->ts.users++;
 189         file->private_data = dev;
 190         err = 0;
 191  done:
 192         up(&dev->ts.ts.lock);
 193         return err;
 194 }
 195
 196 static int ts_release(struct inode *inode, struct file *file)
 197 {
 198         struct saa7134_dev *dev = file->private_data;
 199
 200         if (dev->ts.ts.streaming)
 201                 videobuf_streamoff(file,&dev->ts.ts);
 202         down(&dev->ts.ts.lock);
 203         if (dev->ts.ts.reading)
 204                 videobuf_read_stop(file,&dev->ts.ts);
 205         dev->ts.users--;
 206         up(&dev->ts.ts.lock);
 207         return 0;
 208 }
 209
 210 static ssize_t
 211 ts_read(struct file *file, char *data, size_t count, loff_t *ppos)
 212 {
 213         struct saa7134_dev *dev = file->private_data;
 214
 215         return videobuf_read_stream(file, &dev->ts.ts, data, count, ppos, 0);
 216 }
 217
 218 static unsigned int
 219 ts_poll(struct file *file, struct poll_table_struct *wait)
 220 {
 221         struct saa7134_dev *dev = file->private_data;
 222
 223         return videobuf_poll_stream(file, &dev->ts.ts, wait);
 224 }
 225
 226
 227 static int
 228 ts_mmap(struct file *file, struct vm_area_struct * vma)
 229 {
 230         struct saa7134_dev *dev = file->private_data;
 231
 232         return videobuf_mmap_mapper(vma, &dev->ts.ts);
 233 }
 234
 235 /*
 236  * This function is _not_ called directly, but from
 237  * video_generic_ioctl (and maybe others).  userspace
 238  * copying is done already, arg is a kernel pointer.
 239  */
 240 static int ts_do_ioctl(struct inode *inode, struct file *file,
 241                        unsigned int cmd, void *arg)
 242 {
 243         struct saa7134_dev *dev = file->private_data;
 244
 245         if (ts_debug > 1)
 246                 saa7134_print_ioctl(dev->name,cmd);
 247         switch (cmd) {
 248         case VIDIOC_QUERYCAP:
 249         {
 250                 struct v4l2_capability *cap = arg;
 251
 252                 memset(cap,0,sizeof(*cap));
 253                 strcpy(cap->driver, "saa7134");
 254                 strlcpy(cap->card, saa7134_boards[dev->board].name,
 255                         sizeof(cap->card));
 256                 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
 257                 cap->version = SAA7134_VERSION_CODE;
 258                 cap->capabilities =
 259                         V4L2_CAP_VIDEO_CAPTURE |
 260                         V4L2_CAP_READWRITE |
 261                         V4L2_CAP_STREAMING;
 262                 return 0;
 263         }
 264
 265         /* --- input switching --------------------------------------- */
 266         case VIDIOC_ENUMINPUT:
 267         {
 268                 struct v4l2_input *i = arg;
 269
 270                 if (i->index != 0)
 271                         return -EINVAL;
 272                 i->type = V4L2_INPUT_TYPE_CAMERA;
 273                 strcpy(i->name,"CCIR656");
 274                 return 0;
 275         }
 276         case VIDIOC_G_INPUT:
 277         {
 278                 int *i = arg;
 279                 *i = 0;
 280                 return 0;
 281         }
 282         case VIDIOC_S_INPUT:
 283         {
 284                 int *i = arg;
 285
 286                 if (*i != 0)
 287                         return -EINVAL;
 288                 return 0;
 289         }
 290         /* --- capture ioctls ---------------------------------------- */
 291
 292         case VIDIOC_ENUM_FMT:
 293         {
 294                 struct v4l2_fmtdesc *f = arg;
 295                 int index;
 296
 297                 index = f->index;
 298                 if (index != 0)
 299                         return -EINVAL;
 300
 301                 memset(f,0,sizeof(*f));
 302                 f->index = index;
 303                 strlcpy(f->description, "MPEG TS", sizeof(f->description));
 304                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 305                 f->pixelformat = V4L2_PIX_FMT_MPEG;
 306                 return 0;
 307         }
 308
 309         case VIDIOC_G_FMT:
 310         {
 311                 struct v4l2_format *f = arg;
 312
 313                 memset(f,0,sizeof(*f));
 314                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 315
 316                 /* FIXME: translate subsampling type EMPRESS into
 317                  *        width/height: */
 318                 f->fmt.pix.width        = 720; /* D1 */
 319                 f->fmt.pix.height       = 576;
 320                 f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 321                 f->fmt.pix.sizeimage    = TS_PACKET_SIZE*TS_NR_PACKETS;
 322                 return 0;
 323         }
 324
 325         case VIDIOC_S_FMT:
 326         {
 327                 struct v4l2_format *f = arg;
 328
 329                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 330                     return -EINVAL;
 331
 332                 /*
 333                   FIXME: translate and round width/height into EMPRESS
 334                   subsample type:
 335
 336                           type  |   PAL   |  NTSC
 337                         ---------------------------
 338                           SIF   | 352x288 | 352x240
 339                          1/2 D1 | 352x576 | 352x480
 340                          2/3 D1 | 480x576 | 480x480
 341                           D1    | 720x576 | 720x480
 342                 */
 343
 344                 f->fmt.pix.width        = 720; /* D1 */
 345                 f->fmt.pix.height       = 576;
 346                 f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 347                 f->fmt.pix.sizeimage    = TS_PACKET_SIZE*TS_NR_PACKETS;
 348         }
 349
 350         case VIDIOC_REQBUFS:
 351                 return videobuf_reqbufs(file,&dev->ts.ts,arg);
 352
 353         case VIDIOC_QUERYBUF:
 354                 return videobuf_querybuf(&dev->ts.ts,arg);
 355
 356         case VIDIOC_QBUF:
 357                 return videobuf_qbuf(file,&dev->ts.ts,arg);
 358
 359         case VIDIOC_DQBUF:
 360                 return videobuf_dqbuf(file,&dev->ts.ts,arg);
 361
 362         case VIDIOC_STREAMON:
 363                 return videobuf_streamon(file,&dev->ts.ts);
 364
 365         case VIDIOC_STREAMOFF:
 366                 return videobuf_streamoff(file,&dev->ts.ts);
 367
 368         default:
 369                 return -ENOIOCTLCMD;
 370         }
 371         return 0;
 372 }
 373
 374 static int ts_ioctl(struct inode *inode, struct file *file,
 375                      unsigned int cmd, unsigned long arg)
 376 {
 377         return video_usercopy(inode, file, cmd, arg, ts_do_ioctl);
 378 }
 379
 380
 381 static struct file_operations ts_fops =
 382 {
 383         .owner    = THIS_MODULE,
 384         .open     = ts_open,
 385         .release  = ts_release,
 386         .read     = ts_read,
 387         .poll     = ts_poll,
 388         .mmap     = ts_mmap,
 389         .ioctl    = ts_ioctl,
 390         .llseek   = no_llseek,
 391 };
 392
 393
 394 /* ----------------------------------------------------------- */
 395 /* exported stuff                                              */
 396
 397 struct video_device saa7134_ts_template =
 398 {
 399         .name          = "saa7134-ts",
 400         .type          = 0 /* FIXME */,
 401         .type2         = 0 /* FIXME */,
 402         .hardware      = 0,
 403         .fops          = &ts_fops,
 404         .minor         = -1,
 405 };
 406
 407 int saa7134_ts_init(struct saa7134_dev *dev)
 408 {
 409         /* sanitycheck insmod options */
 410         if (tsbufs < 2)
 411                 tsbufs = 2;
 412         if (tsbufs > VIDEO_MAX_FRAME)
 413                 tsbufs = VIDEO_MAX_FRAME;
 414
 415         INIT_LIST_HEAD(&dev->ts_q.queue);
 416         init_timer(&dev->ts_q.timeout);
 417         dev->ts_q.timeout.function = saa7134_buffer_timeout;
 418         dev->ts_q.timeout.data     = (unsigned long)(&dev->ts_q);
 419         dev->ts_q.dev              = dev;
 420         dev->ts_q.need_two         = 1;
 421         videobuf_queue_init(&dev->ts.ts, &ts_qops, dev->pci, &dev->slock,
 422                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
 423                             V4L2_FIELD_ALTERNATE,
 424                             sizeof(struct saa7134_buf));
 425         saa7134_pgtable_alloc(dev->pci,&dev->ts.pt_ts);
 426
 427         /* init TS hw */
 428         saa_writeb(SAA7134_TS_SERIAL1, 0x00);  /* deactivate TS softreset */
 429         saa_writeb(SAA7134_TS_PARALLEL, 0xec); /* TSSOP high active, TSVAL high active, TSLOCK ignored */
 430         saa_writeb(SAA7134_TS_PARALLEL_SERIAL, (TS_PACKET_SIZE-1));
 431         saa_writeb(SAA7134_TS_DMA0, ((TS_NR_PACKETS-1)&0xff));
 432         saa_writeb(SAA7134_TS_DMA1, (((TS_NR_PACKETS-1)>>8)&0xff));
 433         saa_writeb(SAA7134_TS_DMA2, ((((TS_NR_PACKETS-1)>>16)&0x3f) | 0x00)); /* TSNOPIT=0, TSCOLAP=0 */
 434
 435         return 0;
 436 }
 437
 438 int saa7134_ts_fini(struct saa7134_dev *dev)
 439 {
 440         /* nothing */
 441         saa7134_pgtable_free(dev->pci,&dev->ts.pt_ts);
 442         return 0;
 443 }
 444
 445
 446 void saa7134_irq_ts_done(struct saa7134_dev *dev, unsigned long status)
 447 {
 448         enum v4l2_field field;
 449
 450         spin_lock(&dev->slock);
 451         if (dev->ts_q.curr) {
 452                 field = dev->ts_q.curr->vb.field;
 453                 if (field == V4L2_FIELD_TOP) {
 454                         if ((status & 0x100000) != 0x100000)
 455                                 goto done;
 456                 } else {
 457                         if ((status & 0x100000) != 0x000000)
 458                                 goto done;
 459                 }
 460                 saa7134_buffer_finish(dev,&dev->ts_q,STATE_DONE);
 461         }
 462         saa7134_buffer_next(dev,&dev->ts_q);
 463
 464  done:
 465         spin_unlock(&dev->slock);
 466 }
 467
 468 /* ----------------------------------------------------------- */
 469 /*
 470  * Local variables:
 471  * c-basic-offset: 8
 472  * End:
 473  */