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