pci/ivtv/ivtv-driver.h

0001 /*
0002     ivtv driver internal defines and structures
0003     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
0004     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
0005     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
0006
0007     This program is free software; you can redistribute it and/or modify
0008     it under the terms of the GNU General Public License as published by
0009     the Free Software Foundation; either version 2 of the License, or
0010     (at your option) any later version.
0011
0012     This program is distributed in the hope that it will be useful,
0013     but WITHOUT ANY WARRANTY; without even the implied warranty of
0014     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0015     GNU General Public License for more details.
0016
0017     You should have received a copy of the GNU General Public License
0018     along with this program; if not, write to the Free Software
0019     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
0020  */
0021
0022 #ifndef IVTV_DRIVER_H
0023 #define IVTV_DRIVER_H
0024
0025 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0026
0027 /* Internal header for ivtv project:
0028  * Driver for the cx23415/6 chip.
0029  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
0030  * License: GPL
0031  *
0032  * -----
0033  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
0034  *                      and Takeru KOMORIYA<komoriya@paken.org>
0035  *
0036  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
0037  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
0038  */
0039
0040 #include <linux/module.h>
0041 #include <linux/init.h>
0042 #include <linux/delay.h>
0043 #include <linux/sched/signal.h>
0044 #include <linux/fs.h>
0045 #include <linux/pci.h>
0046 #include <linux/interrupt.h>
0047 #include <linux/spinlock.h>
0048 #include <linux/i2c.h>
0049 #include <linux/i2c-algo-bit.h>
0050 #include <linux/list.h>
0051 #include <linux/unistd.h>
0052 #include <linux/pagemap.h>
0053 #include <linux/scatterlist.h>
0054 #include <linux/kthread.h>
0055 #include <linux/mutex.h>
0056 #include <linux/slab.h>
0057 #include <linux/uaccess.h>
0058 #include <asm/byteorder.h>
0059
0060 #include <media/v4l2-common.h>
0061 #include <media/v4l2-ioctl.h>
0062 #include <media/v4l2-ctrls.h>
0063 #include <media/v4l2-device.h>
0064 #include <media/v4l2-fh.h>
0065 #include <media/tuner.h>
0066 #include <media/drv-intf/cx2341x.h>
0067 #include <media/i2c/ir-kbd-i2c.h>
0068
0069 #include <linux/ivtv.h>
0070
0071 /* Memory layout */
0072 #define IVTV_ENCODER_OFFSET 0x00000000
0073 #define IVTV_ENCODER_SIZE   0x00800000  /* Total size is 0x01000000, but only first half is used */
0074 #define IVTV_DECODER_OFFSET 0x01000000
0075 #define IVTV_DECODER_SIZE   0x00800000  /* Total size is 0x01000000, but only first half is used */
0076 #define IVTV_REG_OFFSET     0x02000000
0077 #define IVTV_REG_SIZE       0x00010000
0078
0079 /* Maximum ivtv driver instances. Some people have a huge number of
0080    capture cards, so set this to a high value. */
0081 #define IVTV_MAX_CARDS 32
0082
0083 #define IVTV_ENC_STREAM_TYPE_MPG  0
0084 #define IVTV_ENC_STREAM_TYPE_YUV  1
0085 #define IVTV_ENC_STREAM_TYPE_VBI  2
0086 #define IVTV_ENC_STREAM_TYPE_PCM  3
0087 #define IVTV_ENC_STREAM_TYPE_RAD  4
0088 #define IVTV_DEC_STREAM_TYPE_MPG  5
0089 #define IVTV_DEC_STREAM_TYPE_VBI  6
0090 #define IVTV_DEC_STREAM_TYPE_VOUT 7
0091 #define IVTV_DEC_STREAM_TYPE_YUV  8
0092 #define IVTV_MAX_STREAMS      9
0093
0094 #define IVTV_DMA_SG_OSD_ENT (2883584/PAGE_SIZE) /* sg entities */
0095
0096 /* DMA Registers */
0097 #define IVTV_REG_DMAXFER    (0x0000)
0098 #define IVTV_REG_DMASTATUS  (0x0004)
0099 #define IVTV_REG_DECDMAADDR (0x0008)
0100 #define IVTV_REG_ENCDMAADDR (0x000c)
0101 #define IVTV_REG_DMACONTROL (0x0010)
0102 #define IVTV_REG_IRQSTATUS  (0x0040)
0103 #define IVTV_REG_IRQMASK    (0x0048)
0104
0105 /* Setup Registers */
0106 #define IVTV_REG_ENC_SDRAM_REFRESH  (0x07F8)
0107 #define IVTV_REG_ENC_SDRAM_PRECHARGE    (0x07FC)
0108 #define IVTV_REG_DEC_SDRAM_REFRESH  (0x08F8)
0109 #define IVTV_REG_DEC_SDRAM_PRECHARGE    (0x08FC)
0110 #define IVTV_REG_VDM            (0x2800)
0111 #define IVTV_REG_AO         (0x2D00)
0112 #define IVTV_REG_BYTEFLUSH      (0x2D24)
0113 #define IVTV_REG_SPU            (0x9050)
0114 #define IVTV_REG_HW_BLOCKS      (0x9054)
0115 #define IVTV_REG_VPU            (0x9058)
0116 #define IVTV_REG_APU            (0xA064)
0117
0118 /* Other registers */
0119 #define IVTV_REG_DEC_LINE_FIELD     (0x28C0)
0120
0121 /* debugging */
0122 extern int ivtv_debug;
0123 #ifdef CONFIG_VIDEO_ADV_DEBUG
0124 extern int ivtv_fw_debug;
0125 #endif
0126
0127 #define IVTV_DBGFLG_WARN    (1 << 0)
0128 #define IVTV_DBGFLG_INFO    (1 << 1)
0129 #define IVTV_DBGFLG_MB      (1 << 2)
0130 #define IVTV_DBGFLG_IOCTL   (1 << 3)
0131 #define IVTV_DBGFLG_FILE    (1 << 4)
0132 #define IVTV_DBGFLG_DMA     (1 << 5)
0133 #define IVTV_DBGFLG_IRQ     (1 << 6)
0134 #define IVTV_DBGFLG_DEC     (1 << 7)
0135 #define IVTV_DBGFLG_YUV     (1 << 8)
0136 #define IVTV_DBGFLG_I2C     (1 << 9)
0137 /* Flag to turn on high volume debugging */
0138 #define IVTV_DBGFLG_HIGHVOL (1 << 10)
0139
0140 #define IVTV_DEBUG(x, type, fmt, args...) \
0141     do { \
0142         if ((x) & ivtv_debug) \
0143             v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args);  \
0144     } while (0)
0145 #define IVTV_DEBUG_WARN(fmt, args...)  IVTV_DEBUG(IVTV_DBGFLG_WARN,  "warn",  fmt , ## args)
0146 #define IVTV_DEBUG_INFO(fmt, args...)  IVTV_DEBUG(IVTV_DBGFLG_INFO,  "info",  fmt , ## args)
0147 #define IVTV_DEBUG_MB(fmt, args...)    IVTV_DEBUG(IVTV_DBGFLG_MB,    "mb",    fmt , ## args)
0148 #define IVTV_DEBUG_DMA(fmt, args...)   IVTV_DEBUG(IVTV_DBGFLG_DMA,   "dma",   fmt , ## args)
0149 #define IVTV_DEBUG_IOCTL(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_IOCTL, "ioctl", fmt , ## args)
0150 #define IVTV_DEBUG_FILE(fmt, args...)  IVTV_DEBUG(IVTV_DBGFLG_FILE,  "file",  fmt , ## args)
0151 #define IVTV_DEBUG_I2C(fmt, args...)   IVTV_DEBUG(IVTV_DBGFLG_I2C,   "i2c",   fmt , ## args)
0152 #define IVTV_DEBUG_IRQ(fmt, args...)   IVTV_DEBUG(IVTV_DBGFLG_IRQ,   "irq",   fmt , ## args)
0153 #define IVTV_DEBUG_DEC(fmt, args...)   IVTV_DEBUG(IVTV_DBGFLG_DEC,   "dec",   fmt , ## args)
0154 #define IVTV_DEBUG_YUV(fmt, args...)   IVTV_DEBUG(IVTV_DBGFLG_YUV,   "yuv",   fmt , ## args)
0155
0156 #define IVTV_DEBUG_HIGH_VOL(x, type, fmt, args...) \
0157     do { \
0158         if (((x) & ivtv_debug) && (ivtv_debug & IVTV_DBGFLG_HIGHVOL))   \
0159             v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args);  \
0160     } while (0)
0161 #define IVTV_DEBUG_HI_WARN(fmt, args...)  IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_WARN,  "warn",  fmt , ## args)
0162 #define IVTV_DEBUG_HI_INFO(fmt, args...)  IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_INFO,  "info",  fmt , ## args)
0163 #define IVTV_DEBUG_HI_MB(fmt, args...)    IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_MB,    "mb",    fmt , ## args)
0164 #define IVTV_DEBUG_HI_DMA(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_DMA,   "dma",   fmt , ## args)
0165 #define IVTV_DEBUG_HI_IOCTL(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_IOCTL, "ioctl", fmt , ## args)
0166 #define IVTV_DEBUG_HI_FILE(fmt, args...)  IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_FILE,  "file",  fmt , ## args)
0167 #define IVTV_DEBUG_HI_I2C(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_I2C,   "i2c",   fmt , ## args)
0168 #define IVTV_DEBUG_HI_IRQ(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_IRQ,   "irq",   fmt , ## args)
0169 #define IVTV_DEBUG_HI_DEC(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_DEC,   "dec",   fmt , ## args)
0170 #define IVTV_DEBUG_HI_YUV(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_YUV,   "yuv",   fmt , ## args)
0171
0172 /* Standard kernel messages */
0173 #define IVTV_ERR(fmt, args...)      v4l2_err(&itv->v4l2_dev, fmt , ## args)
0174 #define IVTV_WARN(fmt, args...)     v4l2_warn(&itv->v4l2_dev, fmt , ## args)
0175 #define IVTV_INFO(fmt, args...)     v4l2_info(&itv->v4l2_dev, fmt , ## args)
0176
0177 /* output modes (cx23415 only) */
0178 #define OUT_NONE        0
0179 #define OUT_MPG         1
0180 #define OUT_YUV         2
0181 #define OUT_UDMA_YUV    3
0182 #define OUT_PASSTHROUGH 4
0183
0184 #define IVTV_MAX_PGM_INDEX (400)
0185
0186 /* Default I2C SCL period in microseconds */
0187 #define IVTV_DEFAULT_I2C_CLOCK_PERIOD   20
0188
0189 struct ivtv_options {
0190     int kilobytes[IVTV_MAX_STREAMS];        /* size in kilobytes of each stream */
0191     int cardtype;               /* force card type on load */
0192     int tuner;              /* set tuner on load */
0193     int radio;              /* enable/disable radio */
0194     int newi2c;             /* new I2C algorithm */
0195     int i2c_clock_period;           /* period of SCL for I2C bus */
0196 };
0197
0198 /* ivtv-specific mailbox template */
0199 struct ivtv_mailbox {
0200     u32 flags;
0201     u32 cmd;
0202     u32 retval;
0203     u32 timeout;
0204     u32 data[CX2341X_MBOX_MAX_DATA];
0205 };
0206
0207 struct ivtv_api_cache {
0208     unsigned long last_jiffies;     /* when last command was issued */
0209     u32 data[CX2341X_MBOX_MAX_DATA];    /* last sent api data */
0210 };
0211
0212 struct ivtv_mailbox_data {
0213     volatile struct ivtv_mailbox __iomem *mbox;
0214     /* Bits 0-2 are for the encoder mailboxes, 0-1 are for the decoder mailboxes.
0215        If the bit is set, then the corresponding mailbox is in use by the driver. */
0216     unsigned long busy;
0217     u8 max_mbox;
0218 };
0219
0220 /* per-buffer bit flags */
0221 #define IVTV_F_B_NEED_BUF_SWAP  (1 << 0)    /* this buffer should be byte swapped */
0222
0223 /* per-stream, s_flags */
0224 #define IVTV_F_S_DMA_PENDING    0   /* this stream has pending DMA */
0225 #define IVTV_F_S_DMA_HAS_VBI    1       /* the current DMA request also requests VBI data */
0226 #define IVTV_F_S_NEEDS_DATA 2   /* this decoding stream needs more data */
0227
0228 #define IVTV_F_S_CLAIMED    3   /* this stream is claimed */
0229 #define IVTV_F_S_STREAMING      4   /* the fw is decoding/encoding this stream */
0230 #define IVTV_F_S_INTERNAL_USE   5   /* this stream is used internally (sliced VBI processing) */
0231 #define IVTV_F_S_PASSTHROUGH    6   /* this stream is in passthrough mode */
0232 #define IVTV_F_S_STREAMOFF  7   /* signal end of stream EOS */
0233 #define IVTV_F_S_APPL_IO        8   /* this stream is used read/written by an application */
0234
0235 #define IVTV_F_S_PIO_PENDING    9   /* this stream has pending PIO */
0236 #define IVTV_F_S_PIO_HAS_VBI    1       /* the current PIO request also requests VBI data */
0237
0238 /* per-ivtv, i_flags */
0239 #define IVTV_F_I_DMA           0    /* DMA in progress */
0240 #define IVTV_F_I_UDMA          1    /* UDMA in progress */
0241 #define IVTV_F_I_UDMA_PENDING      2    /* UDMA pending */
0242 #define IVTV_F_I_SPEED_CHANGE      3    /* a speed change is in progress */
0243 #define IVTV_F_I_EOS           4    /* end of encoder stream reached */
0244 #define IVTV_F_I_RADIO_USER    5    /* the radio tuner is selected */
0245 #define IVTV_F_I_DIG_RST       6    /* reset digitizer */
0246 #define IVTV_F_I_DEC_YUV       7    /* YUV instead of MPG is being decoded */
0247 #define IVTV_F_I_UPDATE_CC     9    /* CC should be updated */
0248 #define IVTV_F_I_UPDATE_WSS    10   /* WSS should be updated */
0249 #define IVTV_F_I_UPDATE_VPS    11   /* VPS should be updated */
0250 #define IVTV_F_I_DECODING_YUV      12   /* this stream is YUV frame decoding */
0251 #define IVTV_F_I_ENC_PAUSED    13   /* the encoder is paused */
0252 #define IVTV_F_I_VALID_DEC_TIMINGS 14   /* last_dec_timing is valid */
0253 #define IVTV_F_I_HAVE_WORK     15   /* used in the interrupt handler: there is work to be done */
0254 #define IVTV_F_I_WORK_HANDLER_VBI  16   /* there is work to be done for VBI */
0255 #define IVTV_F_I_WORK_HANDLER_YUV  17   /* there is work to be done for YUV */
0256 #define IVTV_F_I_WORK_HANDLER_PIO  18   /* there is work to be done for PIO */
0257 #define IVTV_F_I_PIO           19   /* PIO in progress */
0258 #define IVTV_F_I_DEC_PAUSED    20   /* the decoder is paused */
0259 #define IVTV_F_I_INITED        21   /* set after first open */
0260 #define IVTV_F_I_FAILED        22   /* set if first open failed */
0261 #define IVTV_F_I_WORK_HANDLER_PCM  23   /* there is work to be done for PCM */
0262
0263 /* Event notifications */
0264 #define IVTV_F_I_EV_DEC_STOPPED    28   /* decoder stopped event */
0265 #define IVTV_F_I_EV_VSYNC      29   /* VSYNC event */
0266 #define IVTV_F_I_EV_VSYNC_FIELD    30   /* VSYNC event field (0 = first, 1 = second field) */
0267 #define IVTV_F_I_EV_VSYNC_ENABLED  31   /* VSYNC event enabled */
0268
0269 /* Scatter-Gather array element, used in DMA transfers */
0270 struct ivtv_sg_element {
0271     __le32 src;
0272     __le32 dst;
0273     __le32 size;
0274 };
0275
0276 struct ivtv_sg_host_element {
0277     u32 src;
0278     u32 dst;
0279     u32 size;
0280 };
0281
0282 struct ivtv_user_dma {
0283     struct mutex lock;
0284     int page_count;
0285     struct page *map[IVTV_DMA_SG_OSD_ENT];
0286     /* Needed when dealing with highmem userspace buffers */
0287     struct page *bouncemap[IVTV_DMA_SG_OSD_ENT];
0288
0289     /* Base Dev SG Array for cx23415/6 */
0290     struct ivtv_sg_element SGarray[IVTV_DMA_SG_OSD_ENT];
0291     dma_addr_t SG_handle;
0292     int SG_length;
0293
0294     /* SG List of Buffers */
0295     struct scatterlist SGlist[IVTV_DMA_SG_OSD_ENT];
0296 };
0297
0298 struct ivtv_dma_page_info {
0299     unsigned long uaddr;
0300     unsigned long first;
0301     unsigned long last;
0302     unsigned int offset;
0303     unsigned int tail;
0304     int page_count;
0305 };
0306
0307 struct ivtv_buffer {
0308     struct list_head list;
0309     dma_addr_t dma_handle;
0310     unsigned short b_flags;
0311     unsigned short dma_xfer_cnt;
0312     char *buf;
0313     u32 bytesused;
0314     u32 readpos;
0315 };
0316
0317 struct ivtv_queue {
0318     struct list_head list;          /* the list of buffers in this queue */
0319     u32 buffers;                    /* number of buffers in this queue */
0320     u32 length;                     /* total number of bytes of available buffer space */
0321     u32 bytesused;                  /* total number of bytes used in this queue */
0322 };
0323
0324 struct ivtv;                /* forward reference */
0325
0326 struct ivtv_stream {
0327     /* These first four fields are always set, even if the stream
0328        is not actually created. */
0329     struct video_device vdev;   /* vdev.v4l2_dev is NULL if there is no device */
0330     struct ivtv *itv;       /* for ease of use */
0331     const char *name;       /* name of the stream */
0332     int type;           /* stream type */
0333
0334     struct v4l2_fh *fh;     /* pointer to the streaming filehandle */
0335     spinlock_t qlock;       /* locks access to the queues */
0336     unsigned long s_flags;      /* status flags, see above */
0337     int dma;            /* can be PCI_DMA_TODEVICE, PCI_DMA_FROMDEVICE or PCI_DMA_NONE */
0338     u32 pending_offset;
0339     u32 pending_backup;
0340     u64 pending_pts;
0341
0342     u32 dma_offset;
0343     u32 dma_backup;
0344     u64 dma_pts;
0345
0346     int subtype;
0347     wait_queue_head_t waitq;
0348     u32 dma_last_offset;
0349
0350     /* Buffer Stats */
0351     u32 buffers;
0352     u32 buf_size;
0353     u32 buffers_stolen;
0354
0355     /* Buffer Queues */
0356     struct ivtv_queue q_free;   /* free buffers */
0357     struct ivtv_queue q_full;   /* full buffers */
0358     struct ivtv_queue q_io;     /* waiting for I/O */
0359     struct ivtv_queue q_dma;    /* waiting for DMA */
0360     struct ivtv_queue q_predma; /* waiting for DMA */
0361
0362     /* DMA xfer counter, buffers belonging to the same DMA
0363        xfer will have the same dma_xfer_cnt. */
0364     u16 dma_xfer_cnt;
0365
0366     /* Base Dev SG Array for cx23415/6 */
0367     struct ivtv_sg_host_element *sg_pending;
0368     struct ivtv_sg_host_element *sg_processing;
0369     struct ivtv_sg_element *sg_dma;
0370     dma_addr_t sg_handle;
0371     int sg_pending_size;
0372     int sg_processing_size;
0373     int sg_processed;
0374
0375     /* SG List of Buffers */
0376     struct scatterlist *SGlist;
0377 };
0378
0379 struct ivtv_open_id {
0380     struct v4l2_fh fh;
0381     int type;                       /* stream type */
0382     int yuv_frames;                 /* 1: started OUT_UDMA_YUV output mode */
0383     struct ivtv *itv;
0384 };
0385
0386 static inline struct ivtv_open_id *fh2id(struct v4l2_fh *fh)
0387 {
0388     return container_of(fh, struct ivtv_open_id, fh);
0389 }
0390
0391 struct yuv_frame_info
0392 {
0393     u32 update;
0394     s32 src_x;
0395     s32 src_y;
0396     u32 src_w;
0397     u32 src_h;
0398     s32 dst_x;
0399     s32 dst_y;
0400     u32 dst_w;
0401     u32 dst_h;
0402     s32 pan_x;
0403     s32 pan_y;
0404     u32 vis_w;
0405     u32 vis_h;
0406     u32 interlaced_y;
0407     u32 interlaced_uv;
0408     s32 tru_x;
0409     u32 tru_w;
0410     u32 tru_h;
0411     u32 offset_y;
0412     s32 lace_mode;
0413     u32 sync_field;
0414     u32 delay;
0415     u32 interlaced;
0416 };
0417
0418 #define IVTV_YUV_MODE_INTERLACED    0x00
0419 #define IVTV_YUV_MODE_PROGRESSIVE   0x01
0420 #define IVTV_YUV_MODE_AUTO      0x02
0421 #define IVTV_YUV_MODE_MASK      0x03
0422
0423 #define IVTV_YUV_SYNC_EVEN      0x00
0424 #define IVTV_YUV_SYNC_ODD       0x04
0425 #define IVTV_YUV_SYNC_MASK      0x04
0426
0427 #define IVTV_YUV_BUFFERS 8
0428
0429 struct yuv_playback_info
0430 {
0431     u32 reg_2834;
0432     u32 reg_2838;
0433     u32 reg_283c;
0434     u32 reg_2840;
0435     u32 reg_2844;
0436     u32 reg_2848;
0437     u32 reg_2854;
0438     u32 reg_285c;
0439     u32 reg_2864;
0440
0441     u32 reg_2870;
0442     u32 reg_2874;
0443     u32 reg_2890;
0444     u32 reg_2898;
0445     u32 reg_289c;
0446
0447     u32 reg_2918;
0448     u32 reg_291c;
0449     u32 reg_2920;
0450     u32 reg_2924;
0451     u32 reg_2928;
0452     u32 reg_292c;
0453     u32 reg_2930;
0454
0455     u32 reg_2934;
0456
0457     u32 reg_2938;
0458     u32 reg_293c;
0459     u32 reg_2940;
0460     u32 reg_2944;
0461     u32 reg_2948;
0462     u32 reg_294c;
0463     u32 reg_2950;
0464     u32 reg_2954;
0465     u32 reg_2958;
0466     u32 reg_295c;
0467     u32 reg_2960;
0468     u32 reg_2964;
0469     u32 reg_2968;
0470     u32 reg_296c;
0471
0472     u32 reg_2970;
0473
0474     int v_filter_1;
0475     int v_filter_2;
0476     int h_filter;
0477
0478     u8 track_osd; /* Should yuv output track the OSD size & position */
0479
0480     u32 osd_x_offset;
0481     u32 osd_y_offset;
0482
0483     u32 osd_x_pan;
0484     u32 osd_y_pan;
0485
0486     u32 osd_vis_w;
0487     u32 osd_vis_h;
0488
0489     u32 osd_full_w;
0490     u32 osd_full_h;
0491
0492     int decode_height;
0493
0494     int lace_mode;
0495     int lace_threshold;
0496     int lace_sync_field;
0497
0498     atomic_t next_dma_frame;
0499     atomic_t next_fill_frame;
0500
0501     u32 yuv_forced_update;
0502     int update_frame;
0503
0504     u8 fields_lapsed;   /* Counter used when delaying a frame */
0505
0506     struct yuv_frame_info new_frame_info[IVTV_YUV_BUFFERS];
0507     struct yuv_frame_info old_frame_info;
0508     struct yuv_frame_info old_frame_info_args;
0509
0510     void *blanking_ptr;
0511     dma_addr_t blanking_dmaptr;
0512
0513     int stream_size;
0514
0515     u8 draw_frame; /* PVR350 buffer to draw into */
0516     u8 max_frames_buffered; /* Maximum number of frames to buffer */
0517
0518     struct v4l2_rect main_rect;
0519     u32 v4l2_src_w;
0520     u32 v4l2_src_h;
0521
0522     u8 running; /* Have any frames been displayed */
0523 };
0524
0525 #define IVTV_VBI_FRAMES 32
0526
0527 /* VBI data */
0528 struct vbi_cc {
0529     u8 odd[2];  /* two-byte payload of odd field */
0530     u8 even[2]; /* two-byte payload of even field */;
0531 };
0532
0533 struct vbi_vps {
0534     u8 data[5]; /* five-byte VPS payload */
0535 };
0536
0537 struct vbi_info {
0538     /* VBI general data, does not change during streaming */
0539
0540     u32 raw_decoder_line_size;              /* raw VBI line size from digitizer */
0541     u8 raw_decoder_sav_odd_field;           /* raw VBI Start Active Video digitizer code of odd field */
0542     u8 raw_decoder_sav_even_field;          /* raw VBI Start Active Video digitizer code of even field */
0543     u32 sliced_decoder_line_size;           /* sliced VBI line size from digitizer */
0544     u8 sliced_decoder_sav_odd_field;        /* sliced VBI Start Active Video digitizer code of odd field */
0545     u8 sliced_decoder_sav_even_field;       /* sliced VBI Start Active Video digitizer code of even field */
0546
0547     u32 start[2];               /* start of first VBI line in the odd/even fields */
0548     u32 count;              /* number of VBI lines per field */
0549     u32 raw_size;               /* size of raw VBI line from the digitizer */
0550     u32 sliced_size;            /* size of sliced VBI line from the digitizer */
0551
0552     u32 dec_start;              /* start in decoder memory of VBI re-insertion buffers */
0553     u32 enc_start;              /* start in encoder memory of VBI capture buffers */
0554     u32 enc_size;               /* size of VBI capture area */
0555     int fpi;                /* number of VBI frames per interrupt */
0556
0557     struct v4l2_format in;          /* current VBI capture format */
0558     struct v4l2_sliced_vbi_format *sliced_in; /* convenience pointer to sliced struct in vbi.in union */
0559     int insert_mpeg;            /* if non-zero, then embed VBI data in MPEG stream */
0560
0561     /* Raw VBI compatibility hack */
0562
0563     u32 frame;              /* frame counter hack needed for backwards compatibility
0564                            of old VBI software */
0565
0566     /* Sliced VBI output data */
0567
0568     struct vbi_cc cc_payload[256];      /* sliced VBI CC payload array: it is an array to
0569                            prevent dropping CC data if they couldn't be
0570                            processed fast enough */
0571     int cc_payload_idx;         /* index in cc_payload */
0572     u8 cc_missing_cnt;          /* counts number of frames without CC for passthrough mode */
0573     int wss_payload;            /* sliced VBI WSS payload */
0574     u8 wss_missing_cnt;         /* counts number of frames without WSS for passthrough mode */
0575     struct vbi_vps vps_payload;     /* sliced VBI VPS payload */
0576
0577     /* Sliced VBI capture data */
0578
0579     struct v4l2_sliced_vbi_data sliced_data[36];    /* sliced VBI storage for VBI encoder stream */
0580     struct v4l2_sliced_vbi_data sliced_dec_data[36];/* sliced VBI storage for VBI decoder stream */
0581
0582     /* VBI Embedding data */
0583
0584     /* Buffer for VBI data inserted into MPEG stream.
0585        The first byte is a dummy byte that's never used.
0586        The next 16 bytes contain the MPEG header for the VBI data,
0587        the remainder is the actual VBI data.
0588        The max size accepted by the MPEG VBI reinsertion turns out
0589        to be 1552 bytes, which happens to be 4 + (1 + 42) * (2 * 18) bytes,
0590        where 4 is a four byte header, 42 is the max sliced VBI payload, 1 is
0591        a single line header byte and 2 * 18 is the number of VBI lines per frame.
0592
0593        However, it seems that the data must be 1K aligned, so we have to
0594        pad the data until the 1 or 2 K boundary.
0595
0596        This pointer array will allocate 2049 bytes to store each VBI frame. */
0597     u8 *sliced_mpeg_data[IVTV_VBI_FRAMES];
0598     u32 sliced_mpeg_size[IVTV_VBI_FRAMES];
0599     struct ivtv_buffer sliced_mpeg_buf; /* temporary buffer holding data from sliced_mpeg_data */
0600     u32 inserted_frame;         /* index in sliced_mpeg_size of next sliced data
0601                            to be inserted in the MPEG stream */
0602 };
0603
0604 /* forward declaration of struct defined in ivtv-cards.h */
0605 struct ivtv_card;
0606
0607 /* Struct to hold info about ivtv cards */
0608 struct ivtv {
0609     /* General fixed card data */
0610     struct pci_dev *pdev;       /* PCI device */
0611     const struct ivtv_card *card;   /* card information */
0612     const char *card_name;          /* full name of the card */
0613     const struct ivtv_card_tuner_i2c *card_i2c; /* i2c addresses to probe for tuner */
0614     u8 has_cx23415;         /* 1 if it is a cx23415 based card, 0 for cx23416 */
0615     u8 pvr150_workaround;           /* 1 if the cx25840 needs to workaround a PVR150 bug */
0616     u8 nof_inputs;          /* number of video inputs */
0617     u8 nof_audio_inputs;        /* number of audio inputs */
0618     u32 v4l2_cap;           /* V4L2 capabilities of card */
0619     u32 hw_flags;           /* hardware description of the board */
0620     v4l2_std_id tuner_std;      /* the norm of the card's tuner (fixed) */
0621     struct v4l2_subdev *sd_video;   /* controlling video decoder subdev */
0622     struct v4l2_subdev *sd_audio;   /* controlling audio subdev */
0623     struct v4l2_subdev *sd_muxer;   /* controlling audio muxer subdev */
0624     resource_size_t base_addr;      /* PCI resource base address */
0625     volatile void __iomem *enc_mem; /* pointer to mapped encoder memory */
0626     volatile void __iomem *dec_mem; /* pointer to mapped decoder memory */
0627     volatile void __iomem *reg_mem; /* pointer to mapped registers */
0628     struct ivtv_options options;    /* user options */
0629
0630     struct v4l2_device v4l2_dev;
0631     struct cx2341x_handler cxhdl;
0632     struct {
0633         /* PTS/Frame count control cluster */
0634         struct v4l2_ctrl *ctrl_pts;
0635         struct v4l2_ctrl *ctrl_frame;
0636     };
0637     struct {
0638         /* Audio Playback control cluster */
0639         struct v4l2_ctrl *ctrl_audio_playback;
0640         struct v4l2_ctrl *ctrl_audio_multilingual_playback;
0641     };
0642     struct v4l2_ctrl_handler hdl_gpio;
0643     struct v4l2_subdev sd_gpio; /* GPIO sub-device */
0644     u16 instance;
0645
0646     /* High-level state info */
0647     unsigned long i_flags;          /* global ivtv flags */
0648     u8 is_50hz;                     /* 1 if the current capture standard is 50 Hz */
0649     u8 is_60hz                      /* 1 if the current capture standard is 60 Hz */;
0650     u8 is_out_50hz                  /* 1 if the current TV output standard is 50 Hz */;
0651     u8 is_out_60hz                  /* 1 if the current TV output standard is 60 Hz */;
0652     int output_mode;                /* decoder output mode: NONE, MPG, YUV, UDMA YUV, passthrough */
0653     u32 audio_input;                /* current audio input */
0654     u32 active_input;               /* current video input */
0655     u32 active_output;              /* current video output */
0656     v4l2_std_id std;                /* current capture TV standard */
0657     v4l2_std_id std_out;            /* current TV output standard */
0658     u8 audio_stereo_mode;           /* decoder setting how to handle stereo MPEG audio */
0659     u8 audio_bilingual_mode;        /* decoder setting how to handle bilingual MPEG audio */
0660
0661     /* Locking */
0662     spinlock_t lock;                /* lock access to this struct */
0663     struct mutex serialize_lock;    /* mutex used to serialize open/close/start/stop/ioctl operations */
0664
0665     /* Streams */
0666     int stream_buf_size[IVTV_MAX_STREAMS];          /* stream buffer size */
0667     struct ivtv_stream streams[IVTV_MAX_STREAMS];   /* stream data */
0668     atomic_t capturing;     /* count number of active capture streams */
0669     atomic_t decoding;      /* count number of active decoding streams */
0670
0671     /* ALSA interface for PCM capture stream */
0672     struct snd_ivtv_card *alsa;
0673     void (*pcm_announce_callback)(struct snd_ivtv_card *card, u8 *pcm_data,
0674                       size_t num_bytes);
0675
0676     /* Used for ivtv-alsa module loading */
0677     struct work_struct request_module_wk;
0678
0679     /* Interrupts & DMA */
0680     u32 irqmask;                    /* active interrupts */
0681     u32 irq_rr_idx;                 /* round-robin stream index */
0682     struct kthread_worker irq_worker;       /* kthread worker for PIO/YUV/VBI actions */
0683     struct task_struct *irq_worker_task;        /* task for irq_worker */
0684     struct kthread_work irq_work;   /* kthread work entry */
0685     spinlock_t dma_reg_lock;        /* lock access to DMA engine registers */
0686     int cur_dma_stream;     /* index of current stream doing DMA (-1 if none) */
0687     int cur_pio_stream;     /* index of current stream doing PIO (-1 if none) */
0688     u32 dma_data_req_offset;        /* store offset in decoder memory of current DMA request */
0689     u32 dma_data_req_size;          /* store size of current DMA request */
0690     int dma_retries;                /* current DMA retry attempt */
0691     struct ivtv_user_dma udma;      /* user based DMA for OSD */
0692     struct timer_list dma_timer;    /* timer used to catch unfinished DMAs */
0693     u32 last_vsync_field;           /* last seen vsync field */
0694     wait_queue_head_t dma_waitq;    /* wake up when the current DMA is finished */
0695     wait_queue_head_t eos_waitq;    /* wake up when EOS arrives */
0696     wait_queue_head_t event_waitq;  /* wake up when the next decoder event arrives */
0697     wait_queue_head_t vsync_waitq;  /* wake up when the next decoder vsync arrives */
0698
0699
0700     /* Mailbox */
0701     struct ivtv_mailbox_data enc_mbox;              /* encoder mailboxes */
0702     struct ivtv_mailbox_data dec_mbox;              /* decoder mailboxes */
0703     struct ivtv_api_cache api_cache[256];       /* cached API commands */
0704
0705
0706     /* I2C */
0707     struct i2c_adapter i2c_adap;
0708     struct i2c_algo_bit_data i2c_algo;
0709     struct i2c_client i2c_client;
0710     int i2c_state;                  /* i2c bit state */
0711     struct mutex i2c_bus_lock;      /* lock i2c bus */
0712
0713     struct IR_i2c_init_data ir_i2c_init_data;
0714
0715     /* Program Index information */
0716     u32 pgm_info_offset;            /* start of pgm info in encoder memory */
0717     u32 pgm_info_num;               /* number of elements in the pgm cyclic buffer in encoder memory */
0718     u32 pgm_info_write_idx;         /* last index written by the card that was transferred to pgm_info[] */
0719     u32 pgm_info_read_idx;          /* last index in pgm_info read by the application */
0720     struct v4l2_enc_idx_entry pgm_info[IVTV_MAX_PGM_INDEX]; /* filled from the pgm cyclic buffer on the card */
0721
0722
0723     /* Miscellaneous */
0724     u32 open_id;            /* incremented each time an open occurs, is >= 1 */
0725     int search_pack_header;         /* 1 if ivtv_copy_buf_to_user() is scanning for a pack header (0xba) */
0726     int speed;                      /* current playback speed setting */
0727     u8 speed_mute_audio;            /* 1 if audio should be muted when fast forward */
0728     u64 mpg_data_received;          /* number of bytes received from the MPEG stream */
0729     u64 vbi_data_inserted;          /* number of VBI bytes inserted into the MPEG stream */
0730     u32 last_dec_timing[3];         /* cache last retrieved pts/scr/frame values */
0731     unsigned long dualwatch_jiffies;/* jiffies value of the previous dualwatch check */
0732     u32 dualwatch_stereo_mode;      /* current detected dualwatch stereo mode */
0733
0734
0735     /* VBI state info */
0736     struct vbi_info vbi;            /* VBI-specific data */
0737
0738
0739     /* YUV playback */
0740     struct yuv_playback_info yuv_info;              /* YUV playback data */
0741
0742
0743     /* OSD support */
0744     unsigned long osd_video_pbase;
0745     int osd_global_alpha_state;     /* 1 = global alpha is on */
0746     int osd_local_alpha_state;      /* 1 = local alpha is on */
0747     int osd_chroma_key_state;       /* 1 = chroma-keying is on */
0748     u8  osd_global_alpha;           /* current global alpha */
0749     u32 osd_chroma_key;             /* current chroma key */
0750     struct v4l2_rect osd_rect;      /* current OSD position and size */
0751     struct v4l2_rect main_rect;     /* current Main window position and size */
0752     struct osd_info *osd_info;      /* ivtvfb private OSD info */
0753     void (*ivtvfb_restore)(struct ivtv *itv); /* Used for a warm start */
0754 };
0755
0756 static inline struct ivtv *to_ivtv(struct v4l2_device *v4l2_dev)
0757 {
0758     return container_of(v4l2_dev, struct ivtv, v4l2_dev);
0759 }
0760
0761 /* ivtv extensions to be loaded */
0762 extern int (*ivtv_ext_init)(struct ivtv *);
0763
0764 /* Globals */
0765 extern int ivtv_first_minor;
0766
0767 /*==============Prototypes==================*/
0768
0769 /* Hardware/IRQ */
0770 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask);
0771 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask);
0772
0773 /* try to set output mode, return current mode. */
0774 int ivtv_set_output_mode(struct ivtv *itv, int mode);
0775
0776 /* return current output stream based on current mode */
0777 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv);
0778
0779 /* Return non-zero if a signal is pending */
0780 int ivtv_msleep_timeout(unsigned int msecs, int intr);
0781
0782 /* Wait on queue, returns -EINTR if interrupted */
0783 int ivtv_waitq(wait_queue_head_t *waitq);
0784
0785 /* Read Hauppauge eeprom */
0786 struct tveeprom; /* forward reference */
0787 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv);
0788
0789 /* First-open initialization: load firmware, init cx25840, etc. */
0790 int ivtv_init_on_first_open(struct ivtv *itv);
0791
0792 /* Test if the current VBI mode is raw (1) or sliced (0) */
0793 static inline int ivtv_raw_vbi(const struct ivtv *itv)
0794 {
0795     return itv->vbi.in.type == V4L2_BUF_TYPE_VBI_CAPTURE;
0796 }
0797
0798 /* This is a PCI post thing, where if the pci register is not read, then
0799    the write doesn't always take effect right away. By reading back the
0800    register any pending PCI writes will be performed (in order), and so
0801    you can be sure that the writes are guaranteed to be done.
0802
0803    Rarely needed, only in some timing sensitive cases.
0804    Apparently if this is not done some motherboards seem
0805    to kill the firmware and get into the broken state until computer is
0806    rebooted. */
0807 #define write_sync(val, reg) \
0808     do { writel(val, reg); readl(reg); } while (0)
0809
0810 #define read_reg(reg) readl(itv->reg_mem + (reg))
0811 #define write_reg(val, reg) writel(val, itv->reg_mem + (reg))
0812 #define write_reg_sync(val, reg) \
0813     do { write_reg(val, reg); read_reg(reg); } while (0)
0814
0815 #define read_enc(addr) readl(itv->enc_mem + (u32)(addr))
0816 #define write_enc(val, addr) writel(val, itv->enc_mem + (u32)(addr))
0817 #define write_enc_sync(val, addr) \
0818     do { write_enc(val, addr); read_enc(addr); } while (0)
0819
0820 #define read_dec(addr) readl(itv->dec_mem + (u32)(addr))
0821 #define write_dec(val, addr) writel(val, itv->dec_mem + (u32)(addr))
0822 #define write_dec_sync(val, addr) \
0823     do { write_dec(val, addr); read_dec(addr); } while (0)
0824
0825 /* Call the specified callback for all subdevs matching hw (if 0, then
0826    match them all). Ignore any errors. */
0827 #define ivtv_call_hw(itv, hw, o, f, args...)                \
0828     v4l2_device_mask_call_all(&(itv)->v4l2_dev, hw, o, f, ##args)
0829
0830 #define ivtv_call_all(itv, o, f, args...) ivtv_call_hw(itv, 0, o, f , ##args)
0831
0832 /* Call the specified callback for all subdevs matching hw (if 0, then
0833    match them all). If the callback returns an error other than 0 or
0834    -ENOIOCTLCMD, then return with that error code. */
0835 #define ivtv_call_hw_err(itv, hw, o, f, args...)            \
0836     v4l2_device_mask_call_until_err(&(itv)->v4l2_dev, hw, o, f, ##args)
0837
0838 #define ivtv_call_all_err(itv, o, f, args...) ivtv_call_hw_err(itv, 0, o, f , ##args)
0839
0840 #endif