drivers/staging/solo6x10/solo6010-v4l2-enc.c

   1 /*
   2  * Copyright (C) 2010 Bluecherry, LLC www.bluecherrydvr.com
   3  * Copyright (C) 2010 Ben Collins <bcollins@bluecherry.net>
   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/kthread.h>
  23 #include <linux/freezer.h>
  24
  25 #include <media/v4l2-ioctl.h>
  26 #include <media/v4l2-common.h>
  27 #include <media/videobuf-dma-contig.h>
  28
  29 #include "solo6010.h"
  30 #include "solo6010-tw28.h"
  31 #include "solo6010-jpeg.h"
  32
  33 #define MIN_VID_BUFFERS         4
  34 #define FRAME_BUF_SIZE          (128 * 1024)
  35 #define MP4_QS                  16
  36
  37 static int solo_enc_thread(void *data);
  38
  39 extern unsigned video_nr;
  40
  41 struct solo_enc_fh {
  42         struct                  solo_enc_dev *enc;
  43         u32                     fmt;
  44         u16                     rd_idx;
  45         u8                      enc_on;
  46         enum solo_enc_types     type;
  47         struct videobuf_queue   vidq;
  48         struct list_head        vidq_active;
  49         struct task_struct      *kthread;
  50 };
  51
  52 static unsigned char vid_vop_header[] = {
  53         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
  54         0x02, 0x48, 0x05, 0xc0, 0x00, 0x40, 0x00, 0x40,
  55         0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
  56         0x1f, 0x4c, 0x58, 0x10, 0x78, 0x51, 0x18, 0x3e,
  57 };
  58
  59 /*
  60  * Things we can change around:
  61  *
  62  * byte  10,        4-bits 01111000                   aspect
  63  * bytes 21,22,23  16-bits 000x1111 11111111 1111x000 fps/res
  64  * bytes 23,24,25  15-bits 00000n11 11111111 11111x00 interval
  65  * bytes 25,26,27  13-bits 00000x11 11111111 111x0000 width
  66  * bytes 27,28,29  13-bits 000x1111 11111111 1x000000 height
  67  * byte  29         1-bit  0x100000                   interlace
  68  */
  69
  70 /* For aspect */
  71 #define XVID_PAR_43_PAL         2
  72 #define XVID_PAR_43_NTSC        3
  73
  74 static const u32 solo_user_ctrls[] = {
  75         V4L2_CID_BRIGHTNESS,
  76         V4L2_CID_CONTRAST,
  77         V4L2_CID_SATURATION,
  78         V4L2_CID_HUE,
  79         V4L2_CID_SHARPNESS,
  80         0
  81 };
  82
  83 static const u32 solo_mpeg_ctrls[] = {
  84         V4L2_CID_MPEG_VIDEO_ENCODING,
  85         V4L2_CID_MPEG_VIDEO_GOP_SIZE,
  86         0
  87 };
  88
  89 static const u32 solo_private_ctrls[] = {
  90         V4L2_CID_MOTION_ENABLE,
  91         V4L2_CID_MOTION_THRESHOLD,
  92         0
  93 };
  94
  95 static const u32 solo_fmtx_ctrls[] = {
  96         V4L2_CID_RDS_TX_RADIO_TEXT,
  97         0
  98 };
  99
 100 static const u32 *solo_ctrl_classes[] = {
 101         solo_user_ctrls,
 102         solo_mpeg_ctrls,
 103         solo_fmtx_ctrls,
 104         solo_private_ctrls,
 105         NULL
 106 };
 107
 108 struct vop_header {
 109         /* VD_IDX0 */
 110         u32 size:20, sync_start:1, page_stop:1, vop_type:2, channel:4,
 111                 nop0:1, source_fl:1, interlace:1, progressive:1;
 112
 113         /* VD_IDX1 */
 114         u32 vsize:8, hsize:8, frame_interop:1, nop1:7, win_id:4, scale:4;
 115
 116         /* VD_IDX2 */
 117         u32 base_addr:16, nop2:15, hoff:1;
 118
 119         /* VD_IDX3 - User set macros */
 120         u32 sy:12, sx:12, nop3:1, hzoom:1, read_interop:1, write_interlace:1,
 121                 scale_mode:4;
 122
 123         /* VD_IDX4 - User set macros continued */
 124         u32 write_page:8, nop4:24;
 125
 126         /* VD_IDX5 */
 127         u32 next_code_addr;
 128
 129         u32 end_nops[10];
 130 } __attribute__((packed));
 131
 132 static int solo_is_motion_on(struct solo_enc_dev *solo_enc)
 133 {
 134         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 135         u8 ch = solo_enc->ch;
 136
 137         if (solo_dev->motion_mask & (1 << ch))
 138                 return 1;
 139         return 0;
 140 }
 141
 142 static void solo_motion_toggle(struct solo_enc_dev *solo_enc, int on)
 143 {
 144         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 145         u8 ch = solo_enc->ch;
 146
 147         spin_lock(&solo_enc->lock);
 148
 149         if (on)
 150                 solo_dev->motion_mask |= (1 << ch);
 151         else
 152                 solo_dev->motion_mask &= ~(1 << ch);
 153
 154         solo_reg_write(solo_dev, SOLO_VI_MOT_ADR,
 155                        SOLO_VI_MOTION_EN(solo_dev->motion_mask) |
 156                        (SOLO_MOTION_EXT_ADDR(solo_dev) >> 16));
 157
 158         if (solo_dev->motion_mask)
 159                 solo6010_irq_on(solo_dev, SOLO_IRQ_MOTION);
 160         else
 161                 solo6010_irq_off(solo_dev, SOLO_IRQ_MOTION);
 162
 163         spin_unlock(&solo_enc->lock);
 164 }
 165
 166 /* Should be called with solo_enc->lock held */
 167 static void solo_update_mode(struct solo_enc_dev *solo_enc)
 168 {
 169         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 170
 171         assert_spin_locked(&solo_enc->lock);
 172
 173         solo_enc->interlaced = (solo_enc->mode & 0x08) ? 1 : 0;
 174         solo_enc->bw_weight = max(solo_dev->fps / solo_enc->interval, 1);
 175
 176         switch (solo_enc->mode) {
 177         case SOLO_ENC_MODE_CIF:
 178                 solo_enc->width = solo_dev->video_hsize >> 1;
 179                 solo_enc->height = solo_dev->video_vsize;
 180                 break;
 181         case SOLO_ENC_MODE_D1:
 182                 solo_enc->width = solo_dev->video_hsize;
 183                 solo_enc->height = solo_dev->video_vsize << 1;
 184                 solo_enc->bw_weight <<= 2;
 185                 break;
 186         default:
 187                 WARN(1, "mode is unknown");
 188         }
 189 }
 190
 191 /* Should be called with solo_enc->lock held */
 192 static int solo_enc_on(struct solo_enc_fh *fh)
 193 {
 194         struct solo_enc_dev *solo_enc = fh->enc;
 195         u8 ch = solo_enc->ch;
 196         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 197         u8 interval;
 198
 199         assert_spin_locked(&solo_enc->lock);
 200
 201         if (fh->enc_on)
 202                 return 0;
 203
 204         solo_update_mode(solo_enc);
 205
 206         /* Make sure to bw check on first reader */
 207         if (!atomic_read(&solo_enc->readers)) {
 208                 if (solo_enc->bw_weight > solo_dev->enc_bw_remain)
 209                         return -EBUSY;
 210                 else
 211                         solo_dev->enc_bw_remain -= solo_enc->bw_weight;
 212         }
 213
 214         fh->kthread = kthread_run(solo_enc_thread, fh, SOLO6010_NAME "_enc");
 215
 216         if (IS_ERR(fh->kthread))
 217                 return PTR_ERR(fh->kthread);
 218
 219         fh->enc_on = 1;
 220         fh->rd_idx = solo_enc->solo_dev->enc_wr_idx;
 221
 222         if (fh->type == SOLO_ENC_TYPE_EXT)
 223                 solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(ch), 1);
 224
 225         if (atomic_inc_return(&solo_enc->readers) > 1)
 226                 return 0;
 227
 228         /* Disable all encoding for this channel */
 229         solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), 0);
 230
 231         /* Common for both std and ext encoding */
 232         solo_reg_write(solo_dev, SOLO_VE_CH_INTL(ch),
 233                        solo_enc->interlaced ? 1 : 0);
 234
 235         if (solo_enc->interlaced)
 236                 interval = solo_enc->interval - 1;
 237         else
 238                 interval = solo_enc->interval;
 239
 240         /* Standard encoding only */
 241         solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch), solo_enc->gop);
 242         solo_reg_write(solo_dev, SOLO_VE_CH_QP(ch), solo_enc->qp);
 243         solo_reg_write(solo_dev, SOLO_CAP_CH_INTV(ch), interval);
 244
 245         /* Extended encoding only */
 246         solo_reg_write(solo_dev, SOLO_VE_CH_GOP_E(ch), solo_enc->gop);
 247         solo_reg_write(solo_dev, SOLO_VE_CH_QP_E(ch), solo_enc->qp);
 248         solo_reg_write(solo_dev, SOLO_CAP_CH_INTV_E(ch), interval);
 249
 250         /* Enables the standard encoder */
 251         solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), solo_enc->mode);
 252
 253         /* Settle down Beavis... */
 254         mdelay(10);
 255
 256         return 0;
 257 }
 258
 259 static void solo_enc_off(struct solo_enc_fh *fh)
 260 {
 261         struct solo_enc_dev *solo_enc = fh->enc;
 262         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 263
 264         if (!fh->enc_on)
 265                 return;
 266
 267         if (fh->kthread) {
 268                 kthread_stop(fh->kthread);
 269                 fh->kthread = NULL;
 270         }
 271
 272         solo_dev->enc_bw_remain += solo_enc->bw_weight;
 273         fh->enc_on = 0;
 274
 275         if (atomic_dec_return(&solo_enc->readers) > 0)
 276                 return;
 277
 278         solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(solo_enc->ch), 0);
 279         solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(solo_enc->ch), 0);
 280 }
 281
 282 static void enc_reset_gop(struct solo6010_dev *solo_dev, u8 ch)
 283 {
 284         BUG_ON(ch >= solo_dev->nr_chans);
 285         solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch), 1);
 286         solo_dev->v4l2_enc[ch]->reset_gop = 1;
 287 }
 288
 289 static int enc_gop_reset(struct solo6010_dev *solo_dev, u8 ch, u8 vop)
 290 {
 291         BUG_ON(ch >= solo_dev->nr_chans);
 292         if (!solo_dev->v4l2_enc[ch]->reset_gop)
 293                 return 0;
 294         if (vop)
 295                 return 1;
 296         solo_dev->v4l2_enc[ch]->reset_gop = 0;
 297         solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch),
 298                        solo_dev->v4l2_enc[ch]->gop);
 299         return 0;
 300 }
 301
 302 static int enc_get_mpeg_dma_t(struct solo6010_dev *solo_dev, dma_addr_t buf,
 303                               unsigned int off, unsigned int size)
 304 {
 305         int ret;
 306
 307         if (off > SOLO_MP4E_EXT_SIZE(solo_dev))
 308                 return -EINVAL;
 309
 310         if (off + size <= SOLO_MP4E_EXT_SIZE(solo_dev))
 311                 return solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0, buf,
 312                                       SOLO_MP4E_EXT_ADDR(solo_dev) + off, size);
 313
 314         /* Buffer wrap */
 315         ret = solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0, buf,
 316                             SOLO_MP4E_EXT_ADDR(solo_dev) + off,
 317                             SOLO_MP4E_EXT_SIZE(solo_dev) - off);
 318
 319         ret |= solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0,
 320                               buf + SOLO_MP4E_EXT_SIZE(solo_dev) - off,
 321                               SOLO_MP4E_EXT_ADDR(solo_dev),
 322                               size + off - SOLO_MP4E_EXT_SIZE(solo_dev));
 323
 324         return ret;
 325 }
 326
 327 static int enc_get_mpeg_dma(struct solo6010_dev *solo_dev, void *buf,
 328                             unsigned int off, unsigned int size)
 329 {
 330         int ret;
 331
 332         dma_addr_t dma_addr = pci_map_single(solo_dev->pdev, buf, size,
 333                                              PCI_DMA_FROMDEVICE);
 334         ret = enc_get_mpeg_dma_t(solo_dev, dma_addr, off, size);
 335         pci_unmap_single(solo_dev->pdev, dma_addr, size, PCI_DMA_FROMDEVICE);
 336
 337         return ret;
 338 }
 339
 340 static int enc_get_jpeg_dma(struct solo6010_dev *solo_dev, dma_addr_t buf,
 341                             unsigned int off, unsigned int size)
 342 {
 343         int ret;
 344
 345         if (off > SOLO_JPEG_EXT_SIZE(solo_dev))
 346                 return -EINVAL;
 347
 348         if (off + size <= SOLO_JPEG_EXT_SIZE(solo_dev))
 349                 return solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_JPEG, 0, buf,
 350                                       SOLO_JPEG_EXT_ADDR(solo_dev) + off, size);
 351
 352         /* Buffer wrap */
 353         ret = solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_JPEG, 0, buf,
 354                              SOLO_JPEG_EXT_ADDR(solo_dev) + off,
 355                              SOLO_JPEG_EXT_SIZE(solo_dev) - off);
 356
 357         ret |= solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_JPEG, 0,
 358                               buf + SOLO_JPEG_EXT_SIZE(solo_dev) - off,
 359                               SOLO_JPEG_EXT_ADDR(solo_dev),
 360                               size + off - SOLO_JPEG_EXT_SIZE(solo_dev));
 361
 362         return ret;
 363 }
 364
 365 static int solo_fill_jpeg(struct solo_enc_fh *fh, struct solo_enc_buf *enc_buf,
 366                           struct videobuf_buffer *vb, dma_addr_t vbuf)
 367 {
 368         struct solo_enc_dev *solo_enc = fh->enc;
 369         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 370         u8 *p = videobuf_queue_to_vaddr(&fh->vidq, vb);
 371
 372         memcpy(p, jpeg_header, sizeof(jpeg_header));
 373         p[SOF0_START + 5] = 0xff & (solo_enc->height >> 8);
 374         p[SOF0_START + 6] = 0xff & solo_enc->height;
 375         p[SOF0_START + 7] = 0xff & (solo_enc->width >> 8);
 376         p[SOF0_START + 8] = 0xff & solo_enc->width;
 377
 378         vbuf += sizeof(jpeg_header);
 379         vb->size = enc_buf->jpeg_size + sizeof(jpeg_header);
 380
 381         return enc_get_jpeg_dma(solo_dev, vbuf, enc_buf->jpeg_off,
 382                                 enc_buf->jpeg_size);
 383 }
 384
 385 static int solo_fill_mpeg(struct solo_enc_fh *fh, struct solo_enc_buf *enc_buf,
 386                           struct videobuf_buffer *vb, dma_addr_t vbuf)
 387 {
 388         struct solo_enc_dev *solo_enc = fh->enc;
 389         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 390         struct vop_header vh;
 391         int ret;
 392         int frame_size, frame_off;
 393
 394         if (WARN_ON_ONCE(enc_buf->size <= sizeof(vh)))
 395                 return -1;
 396
 397         /* First get the hardware vop header (not real mpeg) */
 398         ret = enc_get_mpeg_dma(solo_dev, &vh, enc_buf->off, sizeof(vh));
 399         if (ret)
 400                 return -1;
 401
 402         if (WARN_ON_ONCE(vh.size > enc_buf->size))
 403                 return -1;
 404
 405         vb->width = vh.hsize << 4;
 406         vb->height = vh.vsize << 4;
 407         vb->size = vh.size;
 408
 409         /* If this is a key frame, add extra m4v header */
 410         if (!enc_buf->vop) {
 411                 u16 fps = solo_dev->fps * 1000;
 412                 u16 interval = solo_enc->interval * 1000;
 413                 u8 *p = videobuf_queue_to_vaddr(&fh->vidq, vb);
 414
 415                 memcpy(p, vid_vop_header, sizeof(vid_vop_header));
 416
 417                 if (solo_dev->video_type == SOLO_VO_FMT_TYPE_NTSC)
 418                         p[10] |= ((XVID_PAR_43_NTSC << 3) & 0x78);
 419                 else
 420                         p[10] |= ((XVID_PAR_43_PAL << 3) & 0x78);
 421
 422                 /* Frame rate and interval */
 423                 p[22] = fps >> 4;
 424                 p[23] = ((fps << 4) & 0xf0) | 0x0c | ((interval >> 13) & 0x3);
 425                 p[24] = (interval >> 5) & 0xff;
 426                 p[25] = ((interval << 3) & 0xf8) | 0x04;
 427
 428                 /* Width and height */
 429                 p[26] = (vb->width >> 3) & 0xff;
 430                 p[27] = ((vb->height >> 9) & 0x0f) | 0x10;
 431                 p[28] = (vb->height >> 1) & 0xff;
 432
 433                 /* Interlace */
 434                 if (vh.interlace)
 435                         p[29] |= 0x20;
 436
 437                 /* Adjust the dma buffer past this header */
 438                 vb->size += sizeof(vid_vop_header);
 439                 vbuf += sizeof(vid_vop_header);
 440         }
 441
 442         /* Now get the actual mpeg payload */
 443         frame_off = (enc_buf->off + sizeof(vh)) % SOLO_MP4E_EXT_SIZE(solo_dev);
 444         frame_size = enc_buf->size - sizeof(vh);
 445         ret = enc_get_mpeg_dma_t(solo_dev, vbuf, frame_off, frame_size);
 446         if (WARN_ON_ONCE(ret))
 447                 return -1;
 448
 449         return 0;
 450 }
 451
 452 /* On successful return (0), leaves solo_enc->lock unlocked */
 453 static int solo_enc_fillbuf(struct solo_enc_fh *fh,
 454                             struct videobuf_buffer *vb)
 455 {
 456         struct solo_enc_dev *solo_enc = fh->enc;
 457         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 458         struct solo_enc_buf *enc_buf = NULL;
 459         dma_addr_t vbuf;
 460         int ret;
 461         u16 idx = fh->rd_idx;
 462
 463         while (idx != solo_dev->enc_wr_idx) {
 464                 struct solo_enc_buf *ebuf = &solo_dev->enc_buf[idx];
 465                 idx = (idx + 1) % SOLO_NR_RING_BUFS;
 466                 if (fh->fmt == V4L2_PIX_FMT_MPEG) {
 467                         if (fh->type != ebuf->type)
 468                                 continue;
 469                         if (ebuf->ch == solo_enc->ch) {
 470                                 enc_buf = ebuf;
 471                                 break;
 472                         }
 473                 } else if (ebuf->ch == solo_enc->ch) {
 474                         /* For mjpeg, keep reading to the newest frame */
 475                         enc_buf = ebuf;
 476                 }
 477         }
 478
 479         fh->rd_idx = idx;
 480
 481         if (!enc_buf)
 482                 return -1;
 483
 484         if ((fh->fmt == V4L2_PIX_FMT_MPEG &&
 485              vb->bsize < enc_buf->size) ||
 486             (fh->fmt == V4L2_PIX_FMT_MJPEG &&
 487              vb->bsize < (enc_buf->jpeg_size + sizeof(jpeg_header)))) {
 488                 return -1;
 489         }
 490
 491         if (!(vbuf = videobuf_to_dma_contig(vb)))
 492                 return -1;
 493
 494         /* Is it ok that we mess with this buffer out of lock? */
 495         spin_unlock(&solo_enc->lock);
 496
 497         if (fh->fmt == V4L2_PIX_FMT_MPEG)
 498                 ret = solo_fill_mpeg(fh, enc_buf, vb, vbuf);
 499         else
 500                 ret = solo_fill_jpeg(fh, enc_buf, vb, vbuf);
 501
 502         if (ret) // Ignore failures
 503                 return 0;
 504
 505         list_del(&vb->queue);
 506         vb->field_count++;
 507         vb->ts = enc_buf->ts;
 508         vb->state = VIDEOBUF_DONE;
 509
 510         wake_up(&vb->done);
 511
 512         return 0;
 513 }
 514
 515 static void solo_enc_thread_try(struct solo_enc_fh *fh)
 516 {
 517         struct solo_enc_dev *solo_enc = fh->enc;
 518         struct videobuf_buffer *vb;
 519
 520         for (;;) {
 521                 spin_lock(&solo_enc->lock);
 522
 523                 if (list_empty(&fh->vidq_active))
 524                         break;
 525
 526                 vb = list_first_entry(&fh->vidq_active,
 527                                       struct videobuf_buffer, queue);
 528
 529                 if (!waitqueue_active(&vb->done))
 530                         break;
 531
 532                 /* On success, returns with solo_enc->lock unlocked */
 533                 if (solo_enc_fillbuf(fh, vb))
 534                         break;
 535         }
 536
 537         assert_spin_locked(&solo_enc->lock);
 538         spin_unlock(&solo_enc->lock);
 539 }
 540
 541 static int solo_enc_thread(void *data)
 542 {
 543         struct solo_enc_fh *fh = data;
 544         struct solo_enc_dev *solo_enc = fh->enc;
 545         DECLARE_WAITQUEUE(wait, current);
 546
 547         set_freezable();
 548         add_wait_queue(&solo_enc->thread_wait, &wait);
 549
 550         for (;;) {
 551                 long timeout = schedule_timeout_interruptible(HZ);
 552                 if (timeout == -ERESTARTSYS || kthread_should_stop())
 553                         break;
 554                 solo_enc_thread_try(fh);
 555                 try_to_freeze();
 556         }
 557
 558         remove_wait_queue(&solo_enc->thread_wait, &wait);
 559
 560         return 0;
 561 }
 562
 563 void solo_motion_isr(struct solo6010_dev *solo_dev)
 564 {
 565         u32 status;
 566         int i;
 567
 568         solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_MOTION);
 569
 570         status = solo_reg_read(solo_dev, SOLO_VI_MOT_STATUS);
 571
 572         for (i = 0; i < solo_dev->nr_chans; i++) {
 573                 struct solo_enc_dev *solo_enc = solo_dev->v4l2_enc[i];
 574
 575                 BUG_ON(solo_enc == NULL);
 576
 577                 if (solo_enc->motion_detected)
 578                         continue;
 579                 if (!(status & (1 << i)))
 580                         continue;
 581
 582                 solo_enc->motion_detected = 1;
 583         }
 584 }
 585
 586 void solo_enc_v4l2_isr(struct solo6010_dev *solo_dev)
 587 {
 588         struct solo_enc_buf *enc_buf;
 589         struct videnc_status vstatus;
 590         u32 mpeg_current, mpeg_next, mpeg_size;
 591         u32 jpeg_current, jpeg_next, jpeg_size;
 592         u32 reg_mpeg_size;
 593         u8 cur_q, vop_type;
 594         u8 ch;
 595         enum solo_enc_types enc_type;
 596
 597         solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_ENCODER);
 598
 599         vstatus.status11 = solo_reg_read(solo_dev, SOLO_VE_STATE(11));
 600         cur_q = (vstatus.status11_st.last_queue + 1) % MP4_QS;
 601
 602         vstatus.status0 = solo_reg_read(solo_dev, SOLO_VE_STATE(0));
 603         reg_mpeg_size = (vstatus.status0_st.mp4_enc_code_size + 64 + 32) &
 604                         (~31);
 605
 606         while (solo_dev->enc_idx != cur_q) {
 607                 mpeg_current = solo_reg_read(solo_dev,
 608                                         SOLO_VE_MPEG4_QUE(solo_dev->enc_idx));
 609                 jpeg_current = solo_reg_read(solo_dev,
 610                                         SOLO_VE_JPEG_QUE(solo_dev->enc_idx));
 611                 solo_dev->enc_idx = (solo_dev->enc_idx + 1) % MP4_QS;
 612                 mpeg_next = solo_reg_read(solo_dev,
 613                                         SOLO_VE_MPEG4_QUE(solo_dev->enc_idx));
 614                 jpeg_next = solo_reg_read(solo_dev,
 615                                         SOLO_VE_JPEG_QUE(solo_dev->enc_idx));
 616
 617                 if ((ch = (mpeg_current >> 24) & 0x1f) >= SOLO_MAX_CHANNELS) {
 618                         ch -= SOLO_MAX_CHANNELS;
 619                         enc_type = SOLO_ENC_TYPE_EXT;
 620                 } else
 621                         enc_type = SOLO_ENC_TYPE_STD;
 622
 623                 vop_type = (mpeg_current >> 29) & 3;
 624
 625                 mpeg_current &= 0x00ffffff;
 626                 mpeg_next    &= 0x00ffffff;
 627                 jpeg_current &= 0x00ffffff;
 628                 jpeg_next    &= 0x00ffffff;
 629
 630                 mpeg_size = (SOLO_MP4E_EXT_SIZE(solo_dev) +
 631                              mpeg_next - mpeg_current) %
 632                             SOLO_MP4E_EXT_SIZE(solo_dev);
 633
 634                 jpeg_size = (SOLO_JPEG_EXT_SIZE(solo_dev) +
 635                              jpeg_next - jpeg_current) %
 636                             SOLO_JPEG_EXT_SIZE(solo_dev);
 637
 638                 /* XXX I think this means we had a ring overflow? */
 639                 if (mpeg_current > mpeg_next && mpeg_size != reg_mpeg_size) {
 640                         enc_reset_gop(solo_dev, ch);
 641                         continue;
 642                 }
 643
 644                 /* When resetting the GOP, skip frames until I-frame */
 645                 if (enc_gop_reset(solo_dev, ch, vop_type))
 646                         continue;
 647
 648                 enc_buf = &solo_dev->enc_buf[solo_dev->enc_wr_idx];
 649
 650                 enc_buf->vop = vop_type;
 651                 enc_buf->ch = ch;
 652                 enc_buf->off = mpeg_current;
 653                 enc_buf->size = mpeg_size;
 654                 enc_buf->jpeg_off = jpeg_current;
 655                 enc_buf->jpeg_size = jpeg_size;
 656                 enc_buf->type = enc_type;
 657
 658                 do_gettimeofday(&enc_buf->ts);
 659
 660                 solo_dev->enc_wr_idx = (solo_dev->enc_wr_idx + 1) %
 661                                         SOLO_NR_RING_BUFS;
 662
 663                 wake_up_interruptible(&solo_dev->v4l2_enc[ch]->thread_wait);
 664         }
 665
 666         return;
 667 }
 668
 669 static int solo_enc_buf_setup(struct videobuf_queue *vq, unsigned int *count,
 670                               unsigned int *size)
 671 {
 672         *size = FRAME_BUF_SIZE;
 673
 674         if (*count < MIN_VID_BUFFERS)
 675                 *count = MIN_VID_BUFFERS;
 676
 677         return 0;
 678 }
 679
 680 static int solo_enc_buf_prepare(struct videobuf_queue *vq,
 681                                 struct videobuf_buffer *vb,
 682                                 enum v4l2_field field)
 683 {
 684         struct solo_enc_fh *fh = vq->priv_data;
 685         struct solo_enc_dev *solo_enc = fh->enc;
 686
 687         vb->size = FRAME_BUF_SIZE;
 688         if (vb->baddr != 0 && vb->bsize < vb->size)
 689                 return -EINVAL;
 690
 691         /* These properties only change when queue is idle */
 692         vb->width = solo_enc->width;
 693         vb->height = solo_enc->height;
 694         vb->field  = field;
 695
 696         if (vb->state == VIDEOBUF_NEEDS_INIT) {
 697                 int rc = videobuf_iolock(vq, vb, NULL);
 698                 if (rc < 0) {
 699                         videobuf_dma_contig_free(vq, vb);
 700                         vb->state = VIDEOBUF_NEEDS_INIT;
 701                         return rc;
 702                 }
 703         }
 704         vb->state = VIDEOBUF_PREPARED;
 705
 706         return 0;
 707 }
 708
 709 static void solo_enc_buf_queue(struct videobuf_queue *vq,
 710                                struct videobuf_buffer *vb)
 711 {
 712         struct solo_enc_fh *fh = vq->priv_data;
 713
 714         vb->state = VIDEOBUF_QUEUED;
 715         list_add_tail(&vb->queue, &fh->vidq_active);
 716         wake_up_interruptible(&fh->enc->thread_wait);
 717 }
 718
 719 static void solo_enc_buf_release(struct videobuf_queue *vq,
 720                                  struct videobuf_buffer *vb)
 721 {
 722         videobuf_dma_contig_free(vq, vb);
 723         vb->state = VIDEOBUF_NEEDS_INIT;
 724 }
 725
 726 static struct videobuf_queue_ops solo_enc_video_qops = {
 727         .buf_setup      = solo_enc_buf_setup,
 728         .buf_prepare    = solo_enc_buf_prepare,
 729         .buf_queue      = solo_enc_buf_queue,
 730         .buf_release    = solo_enc_buf_release,
 731 };
 732
 733 static unsigned int solo_enc_poll(struct file *file,
 734                                   struct poll_table_struct *wait)
 735 {
 736         struct solo_enc_fh *fh = file->private_data;
 737
 738         return videobuf_poll_stream(file, &fh->vidq, wait);
 739 }
 740
 741 static int solo_enc_mmap(struct file *file, struct vm_area_struct *vma)
 742 {
 743         struct solo_enc_fh *fh = file->private_data;
 744
 745         return videobuf_mmap_mapper(&fh->vidq, vma);
 746 }
 747
 748 static int solo_enc_open(struct file *file)
 749 {
 750         struct solo_enc_dev *solo_enc = video_drvdata(file);
 751         struct solo_enc_fh *fh;
 752
 753         if ((fh = kzalloc(sizeof(*fh), GFP_KERNEL)) == NULL)
 754                 return -ENOMEM;
 755
 756         spin_lock(&solo_enc->lock);
 757
 758         fh->enc = solo_enc;
 759         file->private_data = fh;
 760         INIT_LIST_HEAD(&fh->vidq_active);
 761         fh->fmt = V4L2_PIX_FMT_MPEG;
 762         fh->type = SOLO_ENC_TYPE_STD;
 763
 764         videobuf_queue_dma_contig_init(&fh->vidq, &solo_enc_video_qops,
 765                                     &solo_enc->solo_dev->pdev->dev,
 766                                     &solo_enc->lock,
 767                                     V4L2_BUF_TYPE_VIDEO_CAPTURE,
 768                                     V4L2_FIELD_INTERLACED,
 769                                     sizeof(struct videobuf_buffer), fh);
 770
 771         spin_unlock(&solo_enc->lock);
 772
 773         return 0;
 774 }
 775
 776 static ssize_t solo_enc_read(struct file *file, char __user *data,
 777                              size_t count, loff_t *ppos)
 778 {
 779         struct solo_enc_fh *fh = file->private_data;
 780         struct solo_enc_dev *solo_enc = fh->enc;
 781
 782         /* Make sure the encoder is on */
 783         if (!fh->enc_on) {
 784                 int ret;
 785
 786                 spin_lock(&solo_enc->lock);
 787                 ret = solo_enc_on(fh);
 788                 spin_unlock(&solo_enc->lock);
 789                 if (ret)
 790                         return ret;
 791         }
 792
 793         return videobuf_read_stream(&fh->vidq, data, count, ppos, 0,
 794                                     file->f_flags & O_NONBLOCK);
 795 }
 796
 797 static int solo_enc_release(struct file *file)
 798 {
 799         struct solo_enc_fh *fh = file->private_data;
 800
 801         videobuf_stop(&fh->vidq);
 802         videobuf_mmap_free(&fh->vidq);
 803         solo_enc_off(fh);
 804         kfree(fh);
 805
 806         return 0;
 807 }
 808
 809 static int solo_enc_querycap(struct file *file, void  *priv,
 810                              struct v4l2_capability *cap)
 811 {
 812         struct solo_enc_fh *fh = priv;
 813         struct solo_enc_dev *solo_enc = fh->enc;
 814         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 815
 816         strcpy(cap->driver, SOLO6010_NAME);
 817         snprintf(cap->card, sizeof(cap->card), "Softlogic 6010 Enc %d",
 818                  solo_enc->ch);
 819         snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI %s",
 820                  pci_name(solo_dev->pdev));
 821         cap->version = SOLO6010_VER_NUM;
 822         cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
 823                                 V4L2_CAP_READWRITE |
 824                                 V4L2_CAP_STREAMING;
 825         return 0;
 826 }
 827
 828 static int solo_enc_enum_input(struct file *file, void *priv,
 829                                struct v4l2_input *input)
 830 {
 831         struct solo_enc_fh *fh = priv;
 832         struct solo_enc_dev *solo_enc = fh->enc;
 833         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 834
 835         if (input->index)
 836                 return -EINVAL;
 837
 838         snprintf(input->name, sizeof(input->name), "Encoder %d",
 839                  solo_enc->ch + 1);
 840         input->type = V4L2_INPUT_TYPE_CAMERA;
 841
 842         if (solo_dev->video_type == SOLO_VO_FMT_TYPE_NTSC)
 843                 input->std = V4L2_STD_NTSC_M;
 844         else
 845                 input->std = V4L2_STD_PAL_M;
 846
 847         if (!tw28_get_video_status(solo_dev, solo_enc->ch))
 848                 input->status = V4L2_IN_ST_NO_SIGNAL;
 849
 850         return 0;
 851 }
 852
 853 static int solo_enc_set_input(struct file *file, void *priv, unsigned int index)
 854 {
 855         if (index)
 856                 return -EINVAL;
 857
 858         return 0;
 859 }
 860
 861 static int solo_enc_get_input(struct file *file, void *priv,
 862                               unsigned int *index)
 863 {
 864         *index = 0;
 865
 866         return 0;
 867 }
 868
 869 static int solo_enc_enum_fmt_cap(struct file *file, void *priv,
 870                                  struct v4l2_fmtdesc *f)
 871 {
 872         switch (f->index) {
 873         case 0:
 874                 f->pixelformat = V4L2_PIX_FMT_MPEG;
 875                 strcpy(f->description, "MPEG-4 AVC");
 876                 break;
 877         case 1:
 878                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
 879                 strcpy(f->description, "MJPEG");
 880                 break;
 881         default:
 882                 return -EINVAL;
 883         }
 884
 885         f->flags = V4L2_FMT_FLAG_COMPRESSED;
 886
 887         return 0;
 888 }
 889
 890 static int solo_enc_try_fmt_cap(struct file *file, void *priv,
 891                             struct v4l2_format *f)
 892 {
 893         struct solo_enc_fh *fh = priv;
 894         struct solo_enc_dev *solo_enc = fh->enc;
 895         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 896         struct v4l2_pix_format *pix = &f->fmt.pix;
 897
 898         if (pix->pixelformat != V4L2_PIX_FMT_MPEG &&
 899             pix->pixelformat != V4L2_PIX_FMT_MJPEG)
 900                 return -EINVAL;
 901
 902         /* We cannot change width/height in mid read */
 903         if (atomic_read(&solo_enc->readers) > 0) {
 904                 if (pix->width != solo_enc->width ||
 905                     pix->height != solo_enc->height)
 906                         return -EBUSY;
 907         } else if (!(pix->width == solo_dev->video_hsize &&
 908               pix->height == solo_dev->video_vsize << 1) &&
 909             !(pix->width == solo_dev->video_hsize >> 1 &&
 910               pix->height == solo_dev->video_vsize)) {
 911                 /* Default to CIF 1/2 size */
 912                 pix->width = solo_dev->video_hsize >> 1;
 913                 pix->height = solo_dev->video_vsize;
 914         }
 915
 916         if (pix->field == V4L2_FIELD_ANY)
 917                 pix->field = V4L2_FIELD_INTERLACED;
 918         else if (pix->field != V4L2_FIELD_INTERLACED) {
 919                 pix->field = V4L2_FIELD_INTERLACED;
 920         }
 921
 922         /* Just set these */
 923         pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
 924         pix->sizeimage = FRAME_BUF_SIZE;
 925
 926         return 0;
 927 }
 928
 929 static int solo_enc_set_fmt_cap(struct file *file, void *priv,
 930                                 struct v4l2_format *f)
 931 {
 932         struct solo_enc_fh *fh = priv;
 933         struct solo_enc_dev *solo_enc = fh->enc;
 934         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
 935         struct v4l2_pix_format *pix = &f->fmt.pix;
 936         int ret;
 937
 938         spin_lock(&solo_enc->lock);
 939
 940         if ((ret = solo_enc_try_fmt_cap(file, priv, f))) {
 941                 spin_unlock(&solo_enc->lock);
 942                 return ret;
 943         }
 944
 945         if (pix->width == solo_dev->video_hsize)
 946                 solo_enc->mode = SOLO_ENC_MODE_D1;
 947         else
 948                 solo_enc->mode = SOLO_ENC_MODE_CIF;
 949
 950         /* This does not change the encoder at all */
 951         fh->fmt = pix->pixelformat;
 952
 953         if (pix->priv)
 954                 fh->type = SOLO_ENC_TYPE_EXT;
 955         ret = solo_enc_on(fh);
 956
 957         spin_unlock(&solo_enc->lock);
 958
 959         return ret;
 960 }
 961
 962 static int solo_enc_get_fmt_cap(struct file *file, void *priv,
 963                                 struct v4l2_format *f)
 964 {
 965         struct solo_enc_fh *fh = priv;
 966         struct solo_enc_dev *solo_enc = fh->enc;
 967         struct v4l2_pix_format *pix = &f->fmt.pix;
 968
 969         pix->width = solo_enc->width;
 970         pix->height = solo_enc->height;
 971         pix->pixelformat = fh->fmt;
 972         pix->field = solo_enc->interlaced ? V4L2_FIELD_INTERLACED :
 973                      V4L2_FIELD_NONE;
 974         pix->sizeimage = FRAME_BUF_SIZE;
 975         pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
 976
 977         return 0;
 978 }
 979
 980 static int solo_enc_reqbufs(struct file *file, void *priv,
 981                             struct v4l2_requestbuffers *req)
 982 {
 983         struct solo_enc_fh *fh = priv;
 984
 985         return videobuf_reqbufs(&fh->vidq, req);
 986 }
 987
 988 static int solo_enc_querybuf(struct file *file, void *priv,
 989                              struct v4l2_buffer *buf)
 990 {
 991         struct solo_enc_fh *fh = priv;
 992
 993         return videobuf_querybuf(&fh->vidq, buf);
 994 }
 995
 996 static int solo_enc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
 997 {
 998         struct solo_enc_fh *fh = priv;
 999
1000         return videobuf_qbuf(&fh->vidq, buf);
1001 }
1002
1003 static int solo_enc_dqbuf(struct file *file, void *priv,
1004                           struct v4l2_buffer *buf)
1005 {
1006         struct solo_enc_fh *fh = priv;
1007         struct solo_enc_dev *solo_enc = fh->enc;
1008         int ret;
1009
1010         /* Make sure the encoder is on */
1011         if (!fh->enc_on) {
1012                 spin_lock(&solo_enc->lock);
1013                 ret = solo_enc_on(fh);
1014                 spin_unlock(&solo_enc->lock);
1015                 if (ret)
1016                         return ret;
1017         }
1018
1019         ret = videobuf_dqbuf(&fh->vidq, buf, file->f_flags & O_NONBLOCK);
1020         if (ret)
1021                 return ret;
1022
1023         /* Signal motion detection */
1024         if (solo_is_motion_on(solo_enc)) {
1025                 buf->flags |= V4L2_BUF_FLAG_MOTION_ON;
1026                 if (solo_enc->motion_detected) {
1027                         buf->flags |= V4L2_BUF_FLAG_MOTION_DETECTED;
1028                         solo_reg_write(solo_enc->solo_dev, SOLO_VI_MOT_CLEAR,
1029                                        1 << solo_enc->ch);
1030                         solo_enc->motion_detected = 0;
1031                 }
1032         }
1033
1034         /* Check for key frame on mpeg data */
1035         if (fh->fmt == V4L2_PIX_FMT_MPEG) {
1036                 struct videobuf_buffer *vb = fh->vidq.bufs[buf->index];
1037                 u8 *p = videobuf_queue_to_vaddr(&fh->vidq, vb);
1038                 if (p[3] == 0x00)
1039                         buf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1040                 else
1041                         buf->flags |= V4L2_BUF_FLAG_PFRAME;
1042         }
1043
1044         return 0;
1045 }
1046
1047 static int solo_enc_streamon(struct file *file, void *priv,
1048                              enum v4l2_buf_type i)
1049 {
1050         struct solo_enc_fh *fh = priv;
1051
1052         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1053                 return -EINVAL;
1054
1055         return videobuf_streamon(&fh->vidq);
1056 }
1057
1058 static int solo_enc_streamoff(struct file *file, void *priv,
1059                               enum v4l2_buf_type i)
1060 {
1061         struct solo_enc_fh *fh = priv;
1062
1063         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1064                 return -EINVAL;
1065
1066         return videobuf_streamoff(&fh->vidq);
1067 }
1068
1069 static int solo_enc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1070 {
1071         return 0;
1072 }
1073
1074 static int solo_enum_framesizes(struct file *file, void *priv,
1075                                 struct v4l2_frmsizeenum *fsize)
1076 {
1077         struct solo_enc_fh *fh = priv;
1078         struct solo6010_dev *solo_dev = fh->enc->solo_dev;
1079
1080         if (fsize->pixel_format != V4L2_PIX_FMT_MPEG)
1081                 return -EINVAL;
1082
1083         switch (fsize->index) {
1084         case 0:
1085                 fsize->discrete.width = solo_dev->video_hsize >> 1;
1086                 fsize->discrete.height = solo_dev->video_vsize;
1087                 break;
1088         case 1:
1089                 fsize->discrete.width = solo_dev->video_hsize;
1090                 fsize->discrete.height = solo_dev->video_vsize << 1;
1091                 break;
1092         default:
1093                 return -EINVAL;
1094         }
1095
1096         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1097
1098         return 0;
1099 }
1100
1101 static int solo_enum_frameintervals(struct file *file, void *priv,
1102                                     struct v4l2_frmivalenum *fintv)
1103 {
1104         struct solo_enc_fh *fh = priv;
1105         struct solo6010_dev *solo_dev = fh->enc->solo_dev;
1106
1107         if (fintv->pixel_format != V4L2_PIX_FMT_MPEG || fintv->index)
1108                 return -EINVAL;
1109
1110         fintv->type = V4L2_FRMIVAL_TYPE_STEPWISE;
1111
1112         fintv->stepwise.min.numerator = solo_dev->fps;
1113         fintv->stepwise.min.denominator = 1;
1114
1115         fintv->stepwise.max.numerator = solo_dev->fps;
1116         fintv->stepwise.max.denominator = 15;
1117
1118         fintv->stepwise.step.numerator = 1;
1119         fintv->stepwise.step.denominator = 1;
1120
1121         return 0;
1122 }
1123
1124 static int solo_g_parm(struct file *file, void *priv,
1125                        struct v4l2_streamparm *sp)
1126 {
1127         struct solo_enc_fh *fh = priv;
1128         struct solo_enc_dev *solo_enc = fh->enc;
1129         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1130         struct v4l2_captureparm *cp = &sp->parm.capture;
1131
1132         cp->capability = V4L2_CAP_TIMEPERFRAME;
1133         cp->timeperframe.numerator = solo_enc->interval;
1134         cp->timeperframe.denominator = solo_dev->fps;
1135         cp->capturemode = 0;
1136         /* XXX: Shouldn't we be able to get/set this from videobuf? */
1137         cp->readbuffers = 2;
1138
1139         return 0;
1140 }
1141
1142 static int solo_s_parm(struct file *file, void *priv,
1143                        struct v4l2_streamparm *sp)
1144 {
1145         struct solo_enc_fh *fh = priv;
1146         struct solo_enc_dev *solo_enc = fh->enc;
1147         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1148         struct v4l2_captureparm *cp = &sp->parm.capture;
1149
1150         spin_lock(&solo_enc->lock);
1151
1152         if (atomic_read(&solo_enc->readers) > 0) {
1153                 spin_unlock(&solo_enc->lock);
1154                 return -EBUSY;
1155         }
1156
1157         if ((cp->timeperframe.numerator == 0) ||
1158             (cp->timeperframe.denominator == 0)) {
1159                 /* reset framerate */
1160                 cp->timeperframe.numerator = 1;
1161                 cp->timeperframe.denominator = solo_dev->fps;
1162         }
1163
1164         if (cp->timeperframe.denominator != solo_dev->fps)
1165                 cp->timeperframe.denominator = solo_dev->fps;
1166
1167         if (cp->timeperframe.numerator > 15)
1168                 cp->timeperframe.numerator = 15;
1169
1170         solo_enc->interval = cp->timeperframe.numerator;
1171
1172         cp->capability = V4L2_CAP_TIMEPERFRAME;
1173
1174         solo_enc->gop = max(solo_dev->fps / solo_enc->interval, 1);
1175         solo_update_mode(solo_enc);
1176
1177         spin_unlock(&solo_enc->lock);
1178
1179         return 0;
1180 }
1181
1182 static int solo_queryctrl(struct file *file, void *priv,
1183                           struct v4l2_queryctrl *qc)
1184 {
1185         struct solo_enc_fh *fh = priv;
1186         struct solo_enc_dev *solo_enc = fh->enc;
1187         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1188
1189         qc->id = v4l2_ctrl_next(solo_ctrl_classes, qc->id);
1190         if (!qc->id)
1191                 return -EINVAL;
1192
1193         switch (qc->id) {
1194         case V4L2_CID_BRIGHTNESS:
1195         case V4L2_CID_CONTRAST:
1196         case V4L2_CID_SATURATION:
1197         case V4L2_CID_HUE:
1198                 return v4l2_ctrl_query_fill(qc, 0x00, 0xff, 1, 0x80);
1199         case V4L2_CID_SHARPNESS:
1200                 return v4l2_ctrl_query_fill(qc, 0x00, 0x0f, 1, 0x00);
1201         case V4L2_CID_MPEG_VIDEO_ENCODING:
1202                 return v4l2_ctrl_query_fill(
1203                         qc, V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1204                         V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC, 1,
1205                         V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC);
1206         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1207                 return v4l2_ctrl_query_fill(qc, 1, 255, 1, solo_dev->fps);
1208 #ifdef PRIVATE_CIDS
1209         case V4L2_CID_MOTION_THRESHOLD:
1210                 qc->flags |= V4L2_CTRL_FLAG_SLIDER;
1211                 qc->type = V4L2_CTRL_TYPE_INTEGER;
1212                 qc->minimum = 0;
1213                 qc->maximum = 0xffff;
1214                 qc->step = 1;
1215                 qc->default_value = SOLO_DEF_MOT_THRESH;
1216                 strlcpy(qc->name, "Motion Detection Threshold",
1217                         sizeof(qc->name));
1218                 return 0;
1219         case V4L2_CID_MOTION_ENABLE:
1220                 qc->type = V4L2_CTRL_TYPE_BOOLEAN;
1221                 qc->minimum = 0;
1222                 qc->maximum = qc->step = 1;
1223                 qc->default_value = 0;
1224                 strlcpy(qc->name, "Motion Detection Enable", sizeof(qc->name));
1225                 return 0;
1226 #else
1227         case V4L2_CID_MOTION_THRESHOLD:
1228                 return v4l2_ctrl_query_fill(qc, 0, 0xffff, 1,
1229                                             SOLO_DEF_MOT_THRESH);
1230         case V4L2_CID_MOTION_ENABLE:
1231                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1232 #endif
1233         case V4L2_CID_RDS_TX_RADIO_TEXT:
1234                 qc->type = V4L2_CTRL_TYPE_STRING;
1235                 qc->minimum = 0;
1236                 qc->maximum = OSD_TEXT_MAX;
1237                 qc->step = 1;
1238                 qc->default_value = 0;
1239                 strlcpy(qc->name, "OSD Text", sizeof(qc->name));
1240                 return 0;
1241         }
1242
1243         return -EINVAL;
1244 }
1245
1246 static int solo_querymenu(struct file *file, void *priv,
1247                           struct v4l2_querymenu *qmenu)
1248 {
1249         struct v4l2_queryctrl qctrl;
1250         int err;
1251
1252         qctrl.id = qmenu->id;
1253         if ((err = solo_queryctrl(file, priv, &qctrl)))
1254                 return err;
1255
1256         return v4l2_ctrl_query_menu(qmenu, &qctrl, NULL);
1257 }
1258
1259 static int solo_g_ctrl(struct file *file, void *priv,
1260                        struct v4l2_control *ctrl)
1261 {
1262         struct solo_enc_fh *fh = priv;
1263         struct solo_enc_dev *solo_enc = fh->enc;
1264         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1265
1266         switch (ctrl->id) {
1267         case V4L2_CID_BRIGHTNESS:
1268         case V4L2_CID_CONTRAST:
1269         case V4L2_CID_SATURATION:
1270         case V4L2_CID_HUE:
1271         case V4L2_CID_SHARPNESS:
1272                 return tw28_get_ctrl_val(solo_dev, ctrl->id, solo_enc->ch,
1273                                          &ctrl->value);
1274         case V4L2_CID_MPEG_VIDEO_ENCODING:
1275                 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC;
1276                 break;
1277         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1278                 ctrl->value = solo_enc->gop;
1279                 break;
1280         case V4L2_CID_MOTION_THRESHOLD:
1281                 ctrl->value = solo_enc->motion_thresh;
1282                 break;
1283         case V4L2_CID_MOTION_ENABLE:
1284                 ctrl->value = solo_is_motion_on(solo_enc);
1285                 break;
1286         default:
1287                 return -EINVAL;
1288         }
1289
1290         return 0;
1291 }
1292
1293 static int solo_s_ctrl(struct file *file, void *priv,
1294                        struct v4l2_control *ctrl)
1295 {
1296         struct solo_enc_fh *fh = priv;
1297         struct solo_enc_dev *solo_enc = fh->enc;
1298         struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1299
1300         switch (ctrl->id) {
1301         case V4L2_CID_BRIGHTNESS:
1302         case V4L2_CID_CONTRAST:
1303         case V4L2_CID_SATURATION:
1304         case V4L2_CID_HUE:
1305         case V4L2_CID_SHARPNESS:
1306                 return tw28_set_ctrl_val(solo_dev, ctrl->id, solo_enc->ch,
1307                                          ctrl->value);
1308         case V4L2_CID_MPEG_VIDEO_ENCODING:
1309                 if (ctrl->value != V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC)
1310                         return -ERANGE;
1311                 break;
1312         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1313                 if (ctrl->value < 1 || ctrl->value > 255)
1314                         return -ERANGE;
1315                 solo_enc->gop = ctrl->value;
1316                 solo_reg_write(solo_dev, SOLO_VE_CH_GOP(solo_enc->ch),
1317                                solo_enc->gop);
1318                 solo_reg_write(solo_dev, SOLO_VE_CH_GOP_E(solo_enc->ch),
1319                                solo_enc->gop);
1320                 break;
1321         case V4L2_CID_MOTION_THRESHOLD:
1322                 /* TODO accept value on lower 16-bits and use high
1323                  * 16-bits to assign the value to a specific block */
1324                 if (ctrl->value < 0 || ctrl->value > 0xffff)
1325                         return -ERANGE;
1326                 solo_enc->motion_thresh = ctrl->value;
1327                 solo_set_motion_threshold(solo_dev, solo_enc->ch, ctrl->value);
1328                 break;
1329         case V4L2_CID_MOTION_ENABLE:
1330                 solo_motion_toggle(solo_enc, ctrl->value);
1331                 break;
1332         default:
1333                 return -EINVAL;
1334         }
1335
1336         return 0;
1337 }
1338
1339 static int solo_s_ext_ctrls(struct file *file, void *priv,
1340                             struct v4l2_ext_controls *ctrls)
1341 {
1342         struct solo_enc_fh *fh = priv;
1343         struct solo_enc_dev *solo_enc = fh->enc;
1344         int i;
1345
1346         for (i = 0; i < ctrls->count; i++) {
1347                 struct v4l2_ext_control *ctrl = (ctrls->controls + i);
1348                 int err;
1349
1350                 switch (ctrl->id) {
1351                 case V4L2_CID_RDS_TX_RADIO_TEXT:
1352                         if (ctrl->size - 1 > OSD_TEXT_MAX)
1353                                 err = -ERANGE;
1354                         else {
1355                                 err = copy_from_user(solo_enc->osd_text,
1356                                                      ctrl->string,
1357                                                      OSD_TEXT_MAX);
1358                                 solo_enc->osd_text[OSD_TEXT_MAX] = '\0';
1359                                 if (!err)
1360                                         err = solo_osd_print(solo_enc);
1361                         }
1362                         break;
1363                 default:
1364                         err = -EINVAL;
1365                 }
1366
1367                 if (err < 0) {
1368                         ctrls->error_idx = i;
1369                         return err;
1370                 }
1371         }
1372
1373         return 0;
1374 }
1375
1376 static int solo_g_ext_ctrls(struct file *file, void *priv,
1377                             struct v4l2_ext_controls *ctrls)
1378 {
1379         struct solo_enc_fh *fh = priv;
1380         struct solo_enc_dev *solo_enc = fh->enc;
1381         int i;
1382
1383         for (i = 0; i < ctrls->count; i++) {
1384                 struct v4l2_ext_control *ctrl = (ctrls->controls + i);
1385                 int err;
1386
1387                 switch (ctrl->id) {
1388                 case V4L2_CID_RDS_TX_RADIO_TEXT:
1389                         if (ctrl->size < OSD_TEXT_MAX) {
1390                                 ctrl->size = OSD_TEXT_MAX;
1391                                 err = -ENOSPC;
1392                         } else {
1393                                 err = copy_to_user(ctrl->string,
1394                                                    solo_enc->osd_text,
1395                                                    OSD_TEXT_MAX);
1396                         }
1397                         break;
1398                 default:
1399                         err = -EINVAL;
1400                 }
1401
1402                 if (err < 0) {
1403                         ctrls->error_idx = i;
1404                         return err;
1405                 }
1406         }
1407
1408         return 0;
1409 }
1410
1411 static const struct v4l2_file_operations solo_enc_fops = {
1412         .owner                  = THIS_MODULE,
1413         .open                   = solo_enc_open,
1414         .release                = solo_enc_release,
1415         .read                   = solo_enc_read,
1416         .poll                   = solo_enc_poll,
1417         .mmap                   = solo_enc_mmap,
1418         .ioctl                  = video_ioctl2,
1419 };
1420
1421 static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = {
1422         .vidioc_querycap                = solo_enc_querycap,
1423         .vidioc_s_std                   = solo_enc_s_std,
1424         /* Input callbacks */
1425         .vidioc_enum_input              = solo_enc_enum_input,
1426         .vidioc_s_input                 = solo_enc_set_input,
1427         .vidioc_g_input                 = solo_enc_get_input,
1428         /* Video capture format callbacks */
1429         .vidioc_enum_fmt_vid_cap        = solo_enc_enum_fmt_cap,
1430         .vidioc_try_fmt_vid_cap         = solo_enc_try_fmt_cap,
1431         .vidioc_s_fmt_vid_cap           = solo_enc_set_fmt_cap,
1432         .vidioc_g_fmt_vid_cap           = solo_enc_get_fmt_cap,
1433         /* Streaming I/O */
1434         .vidioc_reqbufs                 = solo_enc_reqbufs,
1435         .vidioc_querybuf                = solo_enc_querybuf,
1436         .vidioc_qbuf                    = solo_enc_qbuf,
1437         .vidioc_dqbuf                   = solo_enc_dqbuf,
1438         .vidioc_streamon                = solo_enc_streamon,
1439         .vidioc_streamoff               = solo_enc_streamoff,
1440         /* Frame size and interval */
1441         .vidioc_enum_framesizes         = solo_enum_framesizes,
1442         .vidioc_enum_frameintervals     = solo_enum_frameintervals,
1443         /* Video capture parameters */
1444         .vidioc_s_parm                  = solo_s_parm,
1445         .vidioc_g_parm                  = solo_g_parm,
1446         /* Controls */
1447         .vidioc_queryctrl               = solo_queryctrl,
1448         .vidioc_querymenu               = solo_querymenu,
1449         .vidioc_g_ctrl                  = solo_g_ctrl,
1450         .vidioc_s_ctrl                  = solo_s_ctrl,
1451         .vidioc_g_ext_ctrls             = solo_g_ext_ctrls,
1452         .vidioc_s_ext_ctrls             = solo_s_ext_ctrls,
1453 };
1454
1455 static struct video_device solo_enc_template = {
1456         .name                   = SOLO6010_NAME,
1457         .fops                   = &solo_enc_fops,
1458         .ioctl_ops              = &solo_enc_ioctl_ops,
1459         .minor                  = -1,
1460         .release                = video_device_release,
1461
1462         .tvnorms                = V4L2_STD_NTSC_M | V4L2_STD_PAL_M,
1463         .current_norm           = V4L2_STD_NTSC_M,
1464 };
1465
1466 static struct solo_enc_dev *solo_enc_alloc(struct solo6010_dev *solo_dev, u8 ch)
1467 {
1468         struct solo_enc_dev *solo_enc;
1469         int ret;
1470
1471         solo_enc = kzalloc(sizeof(*solo_enc), GFP_KERNEL);
1472         if (!solo_enc)
1473                 return ERR_PTR(-ENOMEM);
1474
1475         solo_enc->vfd = video_device_alloc();
1476         if (!solo_enc->vfd) {
1477                 kfree(solo_enc);
1478                 return ERR_PTR(-ENOMEM);
1479         }
1480
1481         solo_enc->solo_dev = solo_dev;
1482         solo_enc->ch = ch;
1483
1484         *solo_enc->vfd = solo_enc_template;
1485         solo_enc->vfd->parent = &solo_dev->pdev->dev;
1486         ret = video_register_device(solo_enc->vfd, VFL_TYPE_GRABBER,
1487                                     video_nr);
1488         if (ret < 0) {
1489                 video_device_release(solo_enc->vfd);
1490                 kfree(solo_enc);
1491                 return ERR_PTR(ret);
1492         }
1493
1494         video_set_drvdata(solo_enc->vfd, solo_enc);
1495
1496         snprintf(solo_enc->vfd->name, sizeof(solo_enc->vfd->name),
1497                  "%s-enc (%i/%i)", SOLO6010_NAME, solo_dev->vfd->num,
1498                  solo_enc->vfd->num);
1499
1500         if (video_nr != -1)
1501                 video_nr++;
1502
1503         spin_lock_init(&solo_enc->lock);
1504         init_waitqueue_head(&solo_enc->thread_wait);
1505         atomic_set(&solo_enc->readers, 0);
1506
1507         solo_enc->qp = SOLO_DEFAULT_QP;
1508         solo_enc->gop = solo_dev->fps;
1509         solo_enc->interval = 1;
1510         solo_enc->mode = SOLO_ENC_MODE_CIF;
1511         solo_enc->motion_thresh = SOLO_DEF_MOT_THRESH;
1512
1513         spin_lock(&solo_enc->lock);
1514         solo_update_mode(solo_enc);
1515         spin_unlock(&solo_enc->lock);
1516
1517         return solo_enc;
1518 }
1519
1520 static void solo_enc_free(struct solo_enc_dev *solo_enc)
1521 {
1522         if (solo_enc == NULL)
1523                 return;
1524
1525         video_unregister_device(solo_enc->vfd);
1526         kfree(solo_enc);
1527 }
1528
1529 int solo_enc_v4l2_init(struct solo6010_dev *solo_dev)
1530 {
1531         int i;
1532
1533         for (i = 0; i < solo_dev->nr_chans; i++) {
1534                 solo_dev->v4l2_enc[i] = solo_enc_alloc(solo_dev, i);
1535                 if (IS_ERR(solo_dev->v4l2_enc[i]))
1536                         break;
1537         }
1538
1539         if (i != solo_dev->nr_chans) {
1540                 int ret = PTR_ERR(solo_dev->v4l2_enc[i]);
1541                 while (i--)
1542                         solo_enc_free(solo_dev->v4l2_enc[i]);
1543                 return ret;
1544         }
1545
1546         /* D1@MAX-FPS * 4 */
1547         solo_dev->enc_bw_remain = solo_dev->fps * 4 * 4;
1548
1549         dev_info(&solo_dev->pdev->dev, "Encoders as /dev/video%d-%d\n",
1550                  solo_dev->v4l2_enc[0]->vfd->num,
1551                  solo_dev->v4l2_enc[solo_dev->nr_chans - 1]->vfd->num);
1552
1553         return 0;
1554 }
1555
1556 void solo_enc_v4l2_exit(struct solo6010_dev *solo_dev)
1557 {
1558         int i;
1559
1560         solo6010_irq_off(solo_dev, SOLO_IRQ_MOTION);
1561
1562         for (i = 0; i < solo_dev->nr_chans; i++)
1563                 solo_enc_free(solo_dev->v4l2_enc[i]);
1564 }