Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 1 | /* |
| 2 | ivtv driver internal defines and structures |
| 3 | Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com> |
| 4 | Copyright (C) 2004 Chris Kennedy <c@groovy.org> |
| 5 | Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl> |
| 6 | |
| 7 | This program is free software; you can redistribute it and/or modify |
| 8 | it under the terms of the GNU General Public License as published by |
| 9 | the Free Software Foundation; either version 2 of the License, or |
| 10 | (at your option) any later version. |
| 11 | |
| 12 | This program is distributed in the hope that it will be useful, |
| 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | GNU General Public License for more details. |
| 16 | |
| 17 | You should have received a copy of the GNU General Public License |
| 18 | along with this program; if not, write to the Free Software |
| 19 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 20 | */ |
| 21 | |
| 22 | #ifndef IVTV_DRIVER_H |
| 23 | #define IVTV_DRIVER_H |
| 24 | |
| 25 | /* Internal header for ivtv project: |
| 26 | * Driver for the cx23415/6 chip. |
| 27 | * Author: Kevin Thayer (nufan_wfk at yahoo.com) |
| 28 | * License: GPL |
| 29 | * http://www.ivtvdriver.org |
| 30 | * |
| 31 | * ----- |
| 32 | * MPG600/MPG160 support by T.Adachi <tadachi@tadachi-net.com> |
| 33 | * and Takeru KOMORIYA<komoriya@paken.org> |
| 34 | * |
| 35 | * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org> |
| 36 | * using information provided by Jiun-Kuei Jung @ AVerMedia. |
| 37 | */ |
| 38 | |
| 39 | #include <linux/version.h> |
| 40 | #include <linux/module.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 41 | #include <linux/init.h> |
| 42 | #include <linux/delay.h> |
| 43 | #include <linux/sched.h> |
| 44 | #include <linux/fs.h> |
| 45 | #include <linux/pci.h> |
| 46 | #include <linux/interrupt.h> |
| 47 | #include <linux/spinlock.h> |
| 48 | #include <linux/i2c.h> |
| 49 | #include <linux/i2c-algo-bit.h> |
| 50 | #include <linux/list.h> |
| 51 | #include <linux/unistd.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 52 | #include <linux/pagemap.h> |
Ralf Baechle | 1176360 | 2007-10-23 20:42:11 +0200 | [diff] [blame] | 53 | #include <linux/scatterlist.h> |
Tejun Heo | 7bc4656 | 2010-06-29 10:07:09 +0200 | [diff] [blame] | 54 | #include <linux/kthread.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 55 | #include <linux/mutex.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 56 | #include <linux/slab.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 57 | #include <asm/uaccess.h> |
| 58 | #include <asm/system.h> |
Harvey Harrison | 1a651a0 | 2008-10-18 20:28:37 -0700 | [diff] [blame] | 59 | #include <asm/byteorder.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 60 | |
| 61 | #include <linux/dvb/video.h> |
| 62 | #include <linux/dvb/audio.h> |
| 63 | #include <media/v4l2-common.h> |
Hans Verkuil | 35ea11f | 2008-07-20 08:12:02 -0300 | [diff] [blame] | 64 | #include <media/v4l2-ioctl.h> |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 65 | #include <media/v4l2-device.h> |
Hans Verkuil | 0925019 | 2010-03-27 14:10:13 -0300 | [diff] [blame] | 66 | #include <media/v4l2-fh.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 67 | #include <media/tuner.h> |
| 68 | #include <media/cx2341x.h> |
Andy Walls | ad2fe2d | 2009-11-21 12:52:34 -0300 | [diff] [blame] | 69 | #include <media/ir-kbd-i2c.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 70 | |
Hans Verkuil | 51b39df | 2007-08-26 06:13:04 -0300 | [diff] [blame] | 71 | #include <linux/ivtv.h> |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 72 | |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 73 | /* Memory layout */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 74 | #define IVTV_ENCODER_OFFSET 0x00000000 |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 75 | #define IVTV_ENCODER_SIZE 0x00800000 /* Total size is 0x01000000, but only first half is used */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 76 | #define IVTV_DECODER_OFFSET 0x01000000 |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 77 | #define IVTV_DECODER_SIZE 0x00800000 /* Total size is 0x01000000, but only first half is used */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 78 | #define IVTV_REG_OFFSET 0x02000000 |
| 79 | #define IVTV_REG_SIZE 0x00010000 |
| 80 | |
Hans Verkuil | 32db775 | 2007-07-20 09:29:43 -0300 | [diff] [blame] | 81 | /* Maximum ivtv driver instances. Some people have a huge number of |
| 82 | capture cards, so set this to a high value. */ |
| 83 | #define IVTV_MAX_CARDS 32 |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 84 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 85 | #define IVTV_ENC_STREAM_TYPE_MPG 0 |
| 86 | #define IVTV_ENC_STREAM_TYPE_YUV 1 |
| 87 | #define IVTV_ENC_STREAM_TYPE_VBI 2 |
| 88 | #define IVTV_ENC_STREAM_TYPE_PCM 3 |
| 89 | #define IVTV_ENC_STREAM_TYPE_RAD 4 |
| 90 | #define IVTV_DEC_STREAM_TYPE_MPG 5 |
| 91 | #define IVTV_DEC_STREAM_TYPE_VBI 6 |
| 92 | #define IVTV_DEC_STREAM_TYPE_VOUT 7 |
| 93 | #define IVTV_DEC_STREAM_TYPE_YUV 8 |
| 94 | #define IVTV_MAX_STREAMS 9 |
| 95 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 96 | #define IVTV_DMA_SG_OSD_ENT (2883584/PAGE_SIZE) /* sg entities */ |
| 97 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 98 | /* DMA Registers */ |
| 99 | #define IVTV_REG_DMAXFER (0x0000) |
| 100 | #define IVTV_REG_DMASTATUS (0x0004) |
| 101 | #define IVTV_REG_DECDMAADDR (0x0008) |
| 102 | #define IVTV_REG_ENCDMAADDR (0x000c) |
| 103 | #define IVTV_REG_DMACONTROL (0x0010) |
| 104 | #define IVTV_REG_IRQSTATUS (0x0040) |
| 105 | #define IVTV_REG_IRQMASK (0x0048) |
| 106 | |
| 107 | /* Setup Registers */ |
| 108 | #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8) |
| 109 | #define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC) |
| 110 | #define IVTV_REG_DEC_SDRAM_REFRESH (0x08F8) |
| 111 | #define IVTV_REG_DEC_SDRAM_PRECHARGE (0x08FC) |
| 112 | #define IVTV_REG_VDM (0x2800) |
| 113 | #define IVTV_REG_AO (0x2D00) |
| 114 | #define IVTV_REG_BYTEFLUSH (0x2D24) |
| 115 | #define IVTV_REG_SPU (0x9050) |
| 116 | #define IVTV_REG_HW_BLOCKS (0x9054) |
| 117 | #define IVTV_REG_VPU (0x9058) |
| 118 | #define IVTV_REG_APU (0xA064) |
| 119 | |
Andy Walls | 4e1af31 | 2010-03-13 20:37:25 -0300 | [diff] [blame] | 120 | /* Other registers */ |
| 121 | #define IVTV_REG_DEC_LINE_FIELD (0x28C0) |
| 122 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 123 | /* debugging */ |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 124 | extern int ivtv_debug; |
Ian Armstrong | 914610e | 2010-06-12 13:33:21 -0300 | [diff] [blame] | 125 | #ifdef CONFIG_VIDEO_ADV_DEBUG |
| 126 | extern int ivtv_fw_debug; |
| 127 | #endif |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 128 | |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 129 | #define IVTV_DBGFLG_WARN (1 << 0) |
| 130 | #define IVTV_DBGFLG_INFO (1 << 1) |
| 131 | #define IVTV_DBGFLG_MB (1 << 2) |
| 132 | #define IVTV_DBGFLG_IOCTL (1 << 3) |
| 133 | #define IVTV_DBGFLG_FILE (1 << 4) |
| 134 | #define IVTV_DBGFLG_DMA (1 << 5) |
| 135 | #define IVTV_DBGFLG_IRQ (1 << 6) |
| 136 | #define IVTV_DBGFLG_DEC (1 << 7) |
| 137 | #define IVTV_DBGFLG_YUV (1 << 8) |
| 138 | #define IVTV_DBGFLG_I2C (1 << 9) |
Hans Verkuil | bd58df6 | 2007-07-10 17:47:07 -0300 | [diff] [blame] | 139 | /* Flag to turn on high volume debugging */ |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 140 | #define IVTV_DBGFLG_HIGHVOL (1 << 10) |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 141 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 142 | #define IVTV_DEBUG(x, type, fmt, args...) \ |
| 143 | do { \ |
| 144 | if ((x) & ivtv_debug) \ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 145 | v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args); \ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 146 | } while (0) |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 147 | #define IVTV_DEBUG_WARN(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_WARN, "warn", fmt , ## args) |
| 148 | #define IVTV_DEBUG_INFO(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_INFO, "info", fmt , ## args) |
| 149 | #define IVTV_DEBUG_MB(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_MB, "mb", fmt , ## args) |
| 150 | #define IVTV_DEBUG_DMA(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_DMA, "dma", fmt , ## args) |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 151 | #define IVTV_DEBUG_IOCTL(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_IOCTL, "ioctl", fmt , ## args) |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 152 | #define IVTV_DEBUG_FILE(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_FILE, "file", fmt , ## args) |
| 153 | #define IVTV_DEBUG_I2C(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_I2C, "i2c", fmt , ## args) |
| 154 | #define IVTV_DEBUG_IRQ(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_IRQ, "irq", fmt , ## args) |
| 155 | #define IVTV_DEBUG_DEC(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_DEC, "dec", fmt , ## args) |
| 156 | #define IVTV_DEBUG_YUV(fmt, args...) IVTV_DEBUG(IVTV_DBGFLG_YUV, "yuv", fmt , ## args) |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 157 | |
Hans Verkuil | bd58df6 | 2007-07-10 17:47:07 -0300 | [diff] [blame] | 158 | #define IVTV_DEBUG_HIGH_VOL(x, type, fmt, args...) \ |
| 159 | do { \ |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 160 | if (((x) & ivtv_debug) && (ivtv_debug & IVTV_DBGFLG_HIGHVOL)) \ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 161 | v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args); \ |
Hans Verkuil | bd58df6 | 2007-07-10 17:47:07 -0300 | [diff] [blame] | 162 | } while (0) |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 163 | #define IVTV_DEBUG_HI_WARN(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_WARN, "warn", fmt , ## args) |
| 164 | #define IVTV_DEBUG_HI_INFO(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_INFO, "info", fmt , ## args) |
| 165 | #define IVTV_DEBUG_HI_MB(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_MB, "mb", fmt , ## args) |
| 166 | #define IVTV_DEBUG_HI_DMA(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_DMA, "dma", fmt , ## args) |
Hans Verkuil | bd58df6 | 2007-07-10 17:47:07 -0300 | [diff] [blame] | 167 | #define IVTV_DEBUG_HI_IOCTL(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_IOCTL, "ioctl", fmt , ## args) |
Hans Verkuil | 1aa32c2 | 2007-08-19 06:08:58 -0300 | [diff] [blame] | 168 | #define IVTV_DEBUG_HI_FILE(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_FILE, "file", fmt , ## args) |
| 169 | #define IVTV_DEBUG_HI_I2C(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_I2C, "i2c", fmt , ## args) |
| 170 | #define IVTV_DEBUG_HI_IRQ(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_IRQ, "irq", fmt , ## args) |
| 171 | #define IVTV_DEBUG_HI_DEC(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_DEC, "dec", fmt , ## args) |
| 172 | #define IVTV_DEBUG_HI_YUV(fmt, args...) IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_YUV, "yuv", fmt , ## args) |
Hans Verkuil | bd58df6 | 2007-07-10 17:47:07 -0300 | [diff] [blame] | 173 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 174 | /* Standard kernel messages */ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 175 | #define IVTV_ERR(fmt, args...) v4l2_err(&itv->v4l2_dev, fmt , ## args) |
| 176 | #define IVTV_WARN(fmt, args...) v4l2_warn(&itv->v4l2_dev, fmt , ## args) |
| 177 | #define IVTV_INFO(fmt, args...) v4l2_info(&itv->v4l2_dev, fmt , ## args) |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 178 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 179 | /* output modes (cx23415 only) */ |
| 180 | #define OUT_NONE 0 |
| 181 | #define OUT_MPG 1 |
| 182 | #define OUT_YUV 2 |
| 183 | #define OUT_UDMA_YUV 3 |
| 184 | #define OUT_PASSTHROUGH 4 |
| 185 | |
| 186 | #define IVTV_MAX_PGM_INDEX (400) |
| 187 | |
Andy Walls | f412d36 | 2009-11-21 01:47:45 -0300 | [diff] [blame] | 188 | /* Default I2C SCL period in microseconds */ |
| 189 | #define IVTV_DEFAULT_I2C_CLOCK_PERIOD 20 |
| 190 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 191 | struct ivtv_options { |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 192 | int kilobytes[IVTV_MAX_STREAMS]; /* size in kilobytes of each stream */ |
| 193 | int cardtype; /* force card type on load */ |
| 194 | int tuner; /* set tuner on load */ |
| 195 | int radio; /* enable/disable radio */ |
| 196 | int newi2c; /* new I2C algorithm */ |
Andy Walls | f412d36 | 2009-11-21 01:47:45 -0300 | [diff] [blame] | 197 | int i2c_clock_period; /* period of SCL for I2C bus */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 198 | }; |
| 199 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 200 | /* ivtv-specific mailbox template */ |
| 201 | struct ivtv_mailbox { |
| 202 | u32 flags; |
| 203 | u32 cmd; |
| 204 | u32 retval; |
| 205 | u32 timeout; |
| 206 | u32 data[CX2341X_MBOX_MAX_DATA]; |
| 207 | }; |
| 208 | |
| 209 | struct ivtv_api_cache { |
| 210 | unsigned long last_jiffies; /* when last command was issued */ |
| 211 | u32 data[CX2341X_MBOX_MAX_DATA]; /* last sent api data */ |
| 212 | }; |
| 213 | |
| 214 | struct ivtv_mailbox_data { |
| 215 | volatile struct ivtv_mailbox __iomem *mbox; |
| 216 | /* Bits 0-2 are for the encoder mailboxes, 0-1 are for the decoder mailboxes. |
| 217 | If the bit is set, then the corresponding mailbox is in use by the driver. */ |
| 218 | unsigned long busy; |
| 219 | u8 max_mbox; |
| 220 | }; |
| 221 | |
| 222 | /* per-buffer bit flags */ |
Hans Verkuil | f4071b8 | 2007-07-28 12:07:12 -0300 | [diff] [blame] | 223 | #define IVTV_F_B_NEED_BUF_SWAP (1 << 0) /* this buffer should be byte swapped */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 224 | |
| 225 | /* per-stream, s_flags */ |
| 226 | #define IVTV_F_S_DMA_PENDING 0 /* this stream has pending DMA */ |
| 227 | #define IVTV_F_S_DMA_HAS_VBI 1 /* the current DMA request also requests VBI data */ |
| 228 | #define IVTV_F_S_NEEDS_DATA 2 /* this decoding stream needs more data */ |
| 229 | |
| 230 | #define IVTV_F_S_CLAIMED 3 /* this stream is claimed */ |
| 231 | #define IVTV_F_S_STREAMING 4 /* the fw is decoding/encoding this stream */ |
| 232 | #define IVTV_F_S_INTERNAL_USE 5 /* this stream is used internally (sliced VBI processing) */ |
| 233 | #define IVTV_F_S_PASSTHROUGH 6 /* this stream is in passthrough mode */ |
| 234 | #define IVTV_F_S_STREAMOFF 7 /* signal end of stream EOS */ |
| 235 | #define IVTV_F_S_APPL_IO 8 /* this stream is used read/written by an application */ |
| 236 | |
Hans Verkuil | dc02d50 | 2007-05-19 14:07:16 -0300 | [diff] [blame] | 237 | #define IVTV_F_S_PIO_PENDING 9 /* this stream has pending PIO */ |
| 238 | #define IVTV_F_S_PIO_HAS_VBI 1 /* the current PIO request also requests VBI data */ |
| 239 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 240 | /* per-ivtv, i_flags */ |
Hans Verkuil | 1e13f9e | 2007-03-10 06:52:02 -0300 | [diff] [blame] | 241 | #define IVTV_F_I_DMA 0 /* DMA in progress */ |
| 242 | #define IVTV_F_I_UDMA 1 /* UDMA in progress */ |
| 243 | #define IVTV_F_I_UDMA_PENDING 2 /* UDMA pending */ |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 244 | #define IVTV_F_I_SPEED_CHANGE 3 /* a speed change is in progress */ |
| 245 | #define IVTV_F_I_EOS 4 /* end of encoder stream reached */ |
| 246 | #define IVTV_F_I_RADIO_USER 5 /* the radio tuner is selected */ |
| 247 | #define IVTV_F_I_DIG_RST 6 /* reset digitizer */ |
Hans Verkuil | 1e13f9e | 2007-03-10 06:52:02 -0300 | [diff] [blame] | 248 | #define IVTV_F_I_DEC_YUV 7 /* YUV instead of MPG is being decoded */ |
Hans Verkuil | 1e13f9e | 2007-03-10 06:52:02 -0300 | [diff] [blame] | 249 | #define IVTV_F_I_UPDATE_CC 9 /* CC should be updated */ |
| 250 | #define IVTV_F_I_UPDATE_WSS 10 /* WSS should be updated */ |
| 251 | #define IVTV_F_I_UPDATE_VPS 11 /* VPS should be updated */ |
| 252 | #define IVTV_F_I_DECODING_YUV 12 /* this stream is YUV frame decoding */ |
| 253 | #define IVTV_F_I_ENC_PAUSED 13 /* the encoder is paused */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 254 | #define IVTV_F_I_VALID_DEC_TIMINGS 14 /* last_dec_timing is valid */ |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 255 | #define IVTV_F_I_HAVE_WORK 15 /* used in the interrupt handler: there is work to be done */ |
Hans Verkuil | dc02d50 | 2007-05-19 14:07:16 -0300 | [diff] [blame] | 256 | #define IVTV_F_I_WORK_HANDLER_VBI 16 /* there is work to be done for VBI */ |
| 257 | #define IVTV_F_I_WORK_HANDLER_YUV 17 /* there is work to be done for YUV */ |
| 258 | #define IVTV_F_I_WORK_HANDLER_PIO 18 /* there is work to be done for PIO */ |
| 259 | #define IVTV_F_I_PIO 19 /* PIO in progress */ |
Hans Verkuil | ac42514 | 2007-07-22 08:46:38 -0300 | [diff] [blame] | 260 | #define IVTV_F_I_DEC_PAUSED 20 /* the decoder is paused */ |
Hans Verkuil | c976bc8 | 2007-07-22 12:52:40 -0300 | [diff] [blame] | 261 | #define IVTV_F_I_INITED 21 /* set after first open */ |
| 262 | #define IVTV_F_I_FAILED 22 /* set if first open failed */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 263 | |
| 264 | /* Event notifications */ |
Hans Verkuil | 1e13f9e | 2007-03-10 06:52:02 -0300 | [diff] [blame] | 265 | #define IVTV_F_I_EV_DEC_STOPPED 28 /* decoder stopped event */ |
| 266 | #define IVTV_F_I_EV_VSYNC 29 /* VSYNC event */ |
| 267 | #define IVTV_F_I_EV_VSYNC_FIELD 30 /* VSYNC event field (0 = first, 1 = second field) */ |
| 268 | #define IVTV_F_I_EV_VSYNC_ENABLED 31 /* VSYNC event enabled */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 269 | |
| 270 | /* Scatter-Gather array element, used in DMA transfers */ |
Hans Verkuil | 37093b1 | 2007-07-28 19:45:50 -0300 | [diff] [blame] | 271 | struct ivtv_sg_element { |
Al Viro | b0510f8 | 2008-05-21 00:31:41 -0300 | [diff] [blame] | 272 | __le32 src; |
| 273 | __le32 dst; |
| 274 | __le32 size; |
| 275 | }; |
| 276 | |
| 277 | struct ivtv_sg_host_element { |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 278 | u32 src; |
| 279 | u32 dst; |
| 280 | u32 size; |
| 281 | }; |
| 282 | |
| 283 | struct ivtv_user_dma { |
| 284 | struct mutex lock; |
| 285 | int page_count; |
| 286 | struct page *map[IVTV_DMA_SG_OSD_ENT]; |
Hans Verkuil | 0989fd2c | 2007-08-19 12:25:39 -0300 | [diff] [blame] | 287 | /* Needed when dealing with highmem userspace buffers */ |
| 288 | struct page *bouncemap[IVTV_DMA_SG_OSD_ENT]; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 289 | |
| 290 | /* Base Dev SG Array for cx23415/6 */ |
Hans Verkuil | 37093b1 | 2007-07-28 19:45:50 -0300 | [diff] [blame] | 291 | struct ivtv_sg_element SGarray[IVTV_DMA_SG_OSD_ENT]; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 292 | dma_addr_t SG_handle; |
| 293 | int SG_length; |
| 294 | |
| 295 | /* SG List of Buffers */ |
| 296 | struct scatterlist SGlist[IVTV_DMA_SG_OSD_ENT]; |
| 297 | }; |
| 298 | |
| 299 | struct ivtv_dma_page_info { |
| 300 | unsigned long uaddr; |
| 301 | unsigned long first; |
| 302 | unsigned long last; |
| 303 | unsigned int offset; |
| 304 | unsigned int tail; |
| 305 | int page_count; |
| 306 | }; |
| 307 | |
| 308 | struct ivtv_buffer { |
| 309 | struct list_head list; |
| 310 | dma_addr_t dma_handle; |
Hans Verkuil | f4071b8 | 2007-07-28 12:07:12 -0300 | [diff] [blame] | 311 | unsigned short b_flags; |
| 312 | unsigned short dma_xfer_cnt; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 313 | char *buf; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 314 | u32 bytesused; |
| 315 | u32 readpos; |
| 316 | }; |
| 317 | |
| 318 | struct ivtv_queue { |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 319 | struct list_head list; /* the list of buffers in this queue */ |
| 320 | u32 buffers; /* number of buffers in this queue */ |
| 321 | u32 length; /* total number of bytes of available buffer space */ |
| 322 | u32 bytesused; /* total number of bytes used in this queue */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 323 | }; |
| 324 | |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 325 | struct ivtv; /* forward reference */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 326 | |
| 327 | struct ivtv_stream { |
| 328 | /* These first four fields are always set, even if the stream |
| 329 | is not actually created. */ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 330 | struct video_device *vdev; /* NULL when stream not created */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 331 | struct ivtv *itv; /* for ease of use */ |
| 332 | const char *name; /* name of the stream */ |
| 333 | int type; /* stream type */ |
| 334 | |
| 335 | u32 id; |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 336 | spinlock_t qlock; /* locks access to the queues */ |
| 337 | unsigned long s_flags; /* status flags, see above */ |
| 338 | int dma; /* can be PCI_DMA_TODEVICE, PCI_DMA_FROMDEVICE or PCI_DMA_NONE */ |
Hans Verkuil | 37093b1 | 2007-07-28 19:45:50 -0300 | [diff] [blame] | 339 | u32 pending_offset; |
| 340 | u32 pending_backup; |
| 341 | u64 pending_pts; |
| 342 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 343 | u32 dma_offset; |
| 344 | u32 dma_backup; |
| 345 | u64 dma_pts; |
| 346 | |
| 347 | int subtype; |
| 348 | wait_queue_head_t waitq; |
| 349 | u32 dma_last_offset; |
| 350 | |
| 351 | /* Buffer Stats */ |
| 352 | u32 buffers; |
| 353 | u32 buf_size; |
| 354 | u32 buffers_stolen; |
| 355 | |
| 356 | /* Buffer Queues */ |
| 357 | struct ivtv_queue q_free; /* free buffers */ |
| 358 | struct ivtv_queue q_full; /* full buffers */ |
| 359 | struct ivtv_queue q_io; /* waiting for I/O */ |
| 360 | struct ivtv_queue q_dma; /* waiting for DMA */ |
| 361 | struct ivtv_queue q_predma; /* waiting for DMA */ |
| 362 | |
Hans Verkuil | f4071b8 | 2007-07-28 12:07:12 -0300 | [diff] [blame] | 363 | /* DMA xfer counter, buffers belonging to the same DMA |
| 364 | xfer will have the same dma_xfer_cnt. */ |
| 365 | u16 dma_xfer_cnt; |
| 366 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 367 | /* Base Dev SG Array for cx23415/6 */ |
Al Viro | b0510f8 | 2008-05-21 00:31:41 -0300 | [diff] [blame] | 368 | struct ivtv_sg_host_element *sg_pending; |
| 369 | struct ivtv_sg_host_element *sg_processing; |
Hans Verkuil | 37093b1 | 2007-07-28 19:45:50 -0300 | [diff] [blame] | 370 | struct ivtv_sg_element *sg_dma; |
| 371 | dma_addr_t sg_handle; |
| 372 | int sg_pending_size; |
| 373 | int sg_processing_size; |
| 374 | int sg_processed; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 375 | |
| 376 | /* SG List of Buffers */ |
| 377 | struct scatterlist *SGlist; |
| 378 | }; |
| 379 | |
| 380 | struct ivtv_open_id { |
Hans Verkuil | 0925019 | 2010-03-27 14:10:13 -0300 | [diff] [blame] | 381 | struct v4l2_fh fh; |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 382 | u32 open_id; /* unique ID for this file descriptor */ |
| 383 | int type; /* stream type */ |
| 384 | int yuv_frames; /* 1: started OUT_UDMA_YUV output mode */ |
| 385 | enum v4l2_priority prio; /* priority */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 386 | struct ivtv *itv; |
| 387 | }; |
| 388 | |
Hans Verkuil | 0925019 | 2010-03-27 14:10:13 -0300 | [diff] [blame] | 389 | static inline struct ivtv_open_id *fh2id(struct v4l2_fh *fh) |
| 390 | { |
| 391 | return container_of(fh, struct ivtv_open_id, fh); |
| 392 | } |
| 393 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 394 | struct yuv_frame_info |
| 395 | { |
| 396 | u32 update; |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 397 | s32 src_x; |
| 398 | s32 src_y; |
| 399 | u32 src_w; |
| 400 | u32 src_h; |
| 401 | s32 dst_x; |
| 402 | s32 dst_y; |
| 403 | u32 dst_w; |
| 404 | u32 dst_h; |
| 405 | s32 pan_x; |
| 406 | s32 pan_y; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 407 | u32 vis_w; |
| 408 | u32 vis_h; |
| 409 | u32 interlaced_y; |
| 410 | u32 interlaced_uv; |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 411 | s32 tru_x; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 412 | u32 tru_w; |
| 413 | u32 tru_h; |
| 414 | u32 offset_y; |
Hans Verkuil | 33c0fca | 2007-08-23 06:32:46 -0300 | [diff] [blame] | 415 | s32 lace_mode; |
Ian Armstrong | 3b5c1c8 | 2007-10-22 14:24:26 -0300 | [diff] [blame] | 416 | u32 sync_field; |
| 417 | u32 delay; |
| 418 | u32 interlaced; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 419 | }; |
| 420 | |
| 421 | #define IVTV_YUV_MODE_INTERLACED 0x00 |
| 422 | #define IVTV_YUV_MODE_PROGRESSIVE 0x01 |
| 423 | #define IVTV_YUV_MODE_AUTO 0x02 |
| 424 | #define IVTV_YUV_MODE_MASK 0x03 |
| 425 | |
| 426 | #define IVTV_YUV_SYNC_EVEN 0x00 |
| 427 | #define IVTV_YUV_SYNC_ODD 0x04 |
| 428 | #define IVTV_YUV_SYNC_MASK 0x04 |
| 429 | |
Ian Armstrong | a3e5f5e | 2007-10-20 14:52:55 -0300 | [diff] [blame] | 430 | #define IVTV_YUV_BUFFERS 8 |
| 431 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 432 | struct yuv_playback_info |
| 433 | { |
| 434 | u32 reg_2834; |
| 435 | u32 reg_2838; |
| 436 | u32 reg_283c; |
| 437 | u32 reg_2840; |
| 438 | u32 reg_2844; |
| 439 | u32 reg_2848; |
| 440 | u32 reg_2854; |
| 441 | u32 reg_285c; |
| 442 | u32 reg_2864; |
| 443 | |
| 444 | u32 reg_2870; |
| 445 | u32 reg_2874; |
| 446 | u32 reg_2890; |
| 447 | u32 reg_2898; |
| 448 | u32 reg_289c; |
| 449 | |
| 450 | u32 reg_2918; |
| 451 | u32 reg_291c; |
| 452 | u32 reg_2920; |
| 453 | u32 reg_2924; |
| 454 | u32 reg_2928; |
| 455 | u32 reg_292c; |
| 456 | u32 reg_2930; |
| 457 | |
| 458 | u32 reg_2934; |
| 459 | |
| 460 | u32 reg_2938; |
| 461 | u32 reg_293c; |
| 462 | u32 reg_2940; |
| 463 | u32 reg_2944; |
| 464 | u32 reg_2948; |
| 465 | u32 reg_294c; |
| 466 | u32 reg_2950; |
| 467 | u32 reg_2954; |
| 468 | u32 reg_2958; |
| 469 | u32 reg_295c; |
| 470 | u32 reg_2960; |
| 471 | u32 reg_2964; |
| 472 | u32 reg_2968; |
| 473 | u32 reg_296c; |
| 474 | |
| 475 | u32 reg_2970; |
| 476 | |
| 477 | int v_filter_1; |
| 478 | int v_filter_2; |
| 479 | int h_filter; |
| 480 | |
Ian Armstrong | 88ab075 | 2008-04-22 14:42:14 -0300 | [diff] [blame] | 481 | u8 track_osd; /* Should yuv output track the OSD size & position */ |
| 482 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 483 | u32 osd_x_offset; |
| 484 | u32 osd_y_offset; |
| 485 | |
| 486 | u32 osd_x_pan; |
| 487 | u32 osd_y_pan; |
| 488 | |
| 489 | u32 osd_vis_w; |
| 490 | u32 osd_vis_h; |
| 491 | |
Ian Armstrong | 77aded6 | 2007-11-05 14:27:09 -0300 | [diff] [blame] | 492 | u32 osd_full_w; |
| 493 | u32 osd_full_h; |
| 494 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 495 | int decode_height; |
| 496 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 497 | int lace_mode; |
| 498 | int lace_threshold; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 499 | int lace_sync_field; |
| 500 | |
| 501 | atomic_t next_dma_frame; |
| 502 | atomic_t next_fill_frame; |
| 503 | |
| 504 | u32 yuv_forced_update; |
| 505 | int update_frame; |
Ian Armstrong | bfd7bea | 2007-08-03 10:01:39 -0300 | [diff] [blame] | 506 | |
Ian Armstrong | bfd7bea | 2007-08-03 10:01:39 -0300 | [diff] [blame] | 507 | u8 fields_lapsed; /* Counter used when delaying a frame */ |
| 508 | |
Ian Armstrong | a3e5f5e | 2007-10-20 14:52:55 -0300 | [diff] [blame] | 509 | struct yuv_frame_info new_frame_info[IVTV_YUV_BUFFERS]; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 510 | struct yuv_frame_info old_frame_info; |
| 511 | struct yuv_frame_info old_frame_info_args; |
| 512 | |
| 513 | void *blanking_ptr; |
| 514 | dma_addr_t blanking_dmaptr; |
Ian Armstrong | c240ad0 | 2007-10-16 03:21:46 -0300 | [diff] [blame] | 515 | |
| 516 | int stream_size; |
Ian Armstrong | a3e5f5e | 2007-10-20 14:52:55 -0300 | [diff] [blame] | 517 | |
| 518 | u8 draw_frame; /* PVR350 buffer to draw into */ |
| 519 | u8 max_frames_buffered; /* Maximum number of frames to buffer */ |
Ian Armstrong | 77aded6 | 2007-11-05 14:27:09 -0300 | [diff] [blame] | 520 | |
| 521 | struct v4l2_rect main_rect; |
| 522 | u32 v4l2_src_w; |
| 523 | u32 v4l2_src_h; |
Ian Armstrong | 2bd7ac5 | 2008-10-09 12:04:23 -0300 | [diff] [blame] | 524 | |
| 525 | u8 running; /* Have any frames been displayed */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 526 | }; |
| 527 | |
| 528 | #define IVTV_VBI_FRAMES 32 |
| 529 | |
| 530 | /* VBI data */ |
Hans Verkuil | 2f3a989 | 2007-08-25 14:11:23 -0300 | [diff] [blame] | 531 | struct vbi_cc { |
| 532 | u8 odd[2]; /* two-byte payload of odd field */ |
| 533 | u8 even[2]; /* two-byte payload of even field */; |
| 534 | }; |
| 535 | |
| 536 | struct vbi_vps { |
| 537 | u8 data[5]; /* five-byte VPS payload */ |
| 538 | }; |
| 539 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 540 | struct vbi_info { |
Hans Verkuil | effa0b0 | 2007-08-25 15:09:52 -0300 | [diff] [blame] | 541 | /* VBI general data, does not change during streaming */ |
| 542 | |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 543 | u32 raw_decoder_line_size; /* raw VBI line size from digitizer */ |
| 544 | u8 raw_decoder_sav_odd_field; /* raw VBI Start Active Video digitizer code of odd field */ |
| 545 | u8 raw_decoder_sav_even_field; /* raw VBI Start Active Video digitizer code of even field */ |
| 546 | u32 sliced_decoder_line_size; /* sliced VBI line size from digitizer */ |
| 547 | u8 sliced_decoder_sav_odd_field; /* sliced VBI Start Active Video digitizer code of odd field */ |
| 548 | u8 sliced_decoder_sav_even_field; /* sliced VBI Start Active Video digitizer code of even field */ |
| 549 | |
Hans Verkuil | effa0b0 | 2007-08-25 15:09:52 -0300 | [diff] [blame] | 550 | u32 start[2]; /* start of first VBI line in the odd/even fields */ |
| 551 | u32 count; /* number of VBI lines per field */ |
| 552 | u32 raw_size; /* size of raw VBI line from the digitizer */ |
| 553 | u32 sliced_size; /* size of sliced VBI line from the digitizer */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 554 | |
Hans Verkuil | effa0b0 | 2007-08-25 15:09:52 -0300 | [diff] [blame] | 555 | u32 dec_start; /* start in decoder memory of VBI re-insertion buffers */ |
| 556 | u32 enc_start; /* start in encoder memory of VBI capture buffers */ |
| 557 | u32 enc_size; /* size of VBI capture area */ |
| 558 | int fpi; /* number of VBI frames per interrupt */ |
| 559 | |
| 560 | struct v4l2_format in; /* current VBI capture format */ |
| 561 | struct v4l2_sliced_vbi_format *sliced_in; /* convenience pointer to sliced struct in vbi.in union */ |
| 562 | int insert_mpeg; /* if non-zero, then embed VBI data in MPEG stream */ |
| 563 | |
| 564 | /* Raw VBI compatibility hack */ |
| 565 | |
| 566 | u32 frame; /* frame counter hack needed for backwards compatibility |
| 567 | of old VBI software */ |
| 568 | |
| 569 | /* Sliced VBI output data */ |
| 570 | |
| 571 | struct vbi_cc cc_payload[256]; /* sliced VBI CC payload array: it is an array to |
| 572 | prevent dropping CC data if they couldn't be |
| 573 | processed fast enough */ |
| 574 | int cc_payload_idx; /* index in cc_payload */ |
| 575 | u8 cc_missing_cnt; /* counts number of frames without CC for passthrough mode */ |
| 576 | int wss_payload; /* sliced VBI WSS payload */ |
| 577 | u8 wss_missing_cnt; /* counts number of frames without WSS for passthrough mode */ |
| 578 | struct vbi_vps vps_payload; /* sliced VBI VPS payload */ |
| 579 | |
| 580 | /* Sliced VBI capture data */ |
| 581 | |
| 582 | struct v4l2_sliced_vbi_data sliced_data[36]; /* sliced VBI storage for VBI encoder stream */ |
| 583 | struct v4l2_sliced_vbi_data sliced_dec_data[36];/* sliced VBI storage for VBI decoder stream */ |
| 584 | |
| 585 | /* VBI Embedding data */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 586 | |
| 587 | /* Buffer for VBI data inserted into MPEG stream. |
| 588 | The first byte is a dummy byte that's never used. |
| 589 | The next 16 bytes contain the MPEG header for the VBI data, |
| 590 | the remainder is the actual VBI data. |
| 591 | The max size accepted by the MPEG VBI reinsertion turns out |
| 592 | to be 1552 bytes, which happens to be 4 + (1 + 42) * (2 * 18) bytes, |
| 593 | where 4 is a four byte header, 42 is the max sliced VBI payload, 1 is |
| 594 | a single line header byte and 2 * 18 is the number of VBI lines per frame. |
| 595 | |
| 596 | However, it seems that the data must be 1K aligned, so we have to |
| 597 | pad the data until the 1 or 2 K boundary. |
| 598 | |
| 599 | This pointer array will allocate 2049 bytes to store each VBI frame. */ |
| 600 | u8 *sliced_mpeg_data[IVTV_VBI_FRAMES]; |
| 601 | u32 sliced_mpeg_size[IVTV_VBI_FRAMES]; |
Hans Verkuil | effa0b0 | 2007-08-25 15:09:52 -0300 | [diff] [blame] | 602 | struct ivtv_buffer sliced_mpeg_buf; /* temporary buffer holding data from sliced_mpeg_data */ |
| 603 | u32 inserted_frame; /* index in sliced_mpeg_size of next sliced data |
| 604 | to be inserted in the MPEG stream */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 605 | }; |
| 606 | |
| 607 | /* forward declaration of struct defined in ivtv-cards.h */ |
| 608 | struct ivtv_card; |
| 609 | |
| 610 | /* Struct to hold info about ivtv cards */ |
| 611 | struct ivtv { |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 612 | /* General fixed card data */ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 613 | struct pci_dev *pdev; /* PCI device */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 614 | const struct ivtv_card *card; /* card information */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 615 | const char *card_name; /* full name of the card */ |
Hans Verkuil | d900920 | 2007-12-07 21:01:15 -0300 | [diff] [blame] | 616 | const struct ivtv_card_tuner_i2c *card_i2c; /* i2c addresses to probe for tuner */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 617 | u8 has_cx23415; /* 1 if it is a cx23415 based card, 0 for cx23416 */ |
| 618 | u8 pvr150_workaround; /* 1 if the cx25840 needs to workaround a PVR150 bug */ |
| 619 | u8 nof_inputs; /* number of video inputs */ |
| 620 | u8 nof_audio_inputs; /* number of audio inputs */ |
| 621 | u32 v4l2_cap; /* V4L2 capabilities of card */ |
| 622 | u32 hw_flags; /* hardware description of the board */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 623 | v4l2_std_id tuner_std; /* the norm of the card's tuner (fixed) */ |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 624 | struct v4l2_subdev *sd_video; /* controlling video decoder subdev */ |
| 625 | struct v4l2_subdev *sd_audio; /* controlling audio subdev */ |
| 626 | struct v4l2_subdev *sd_muxer; /* controlling audio muxer subdev */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 627 | u32 base_addr; /* PCI resource base address */ |
| 628 | volatile void __iomem *enc_mem; /* pointer to mapped encoder memory */ |
| 629 | volatile void __iomem *dec_mem; /* pointer to mapped decoder memory */ |
| 630 | volatile void __iomem *reg_mem; /* pointer to mapped registers */ |
| 631 | struct ivtv_options options; /* user options */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 632 | |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 633 | struct v4l2_device v4l2_dev; |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 634 | struct v4l2_subdev sd_gpio; /* GPIO sub-device */ |
| 635 | u16 instance; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 636 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 637 | /* High-level state info */ |
| 638 | unsigned long i_flags; /* global ivtv flags */ |
| 639 | u8 is_50hz; /* 1 if the current capture standard is 50 Hz */ |
| 640 | u8 is_60hz /* 1 if the current capture standard is 60 Hz */; |
| 641 | u8 is_out_50hz /* 1 if the current TV output standard is 50 Hz */; |
| 642 | u8 is_out_60hz /* 1 if the current TV output standard is 60 Hz */; |
| 643 | int output_mode; /* decoder output mode: NONE, MPG, YUV, UDMA YUV, passthrough */ |
| 644 | u32 audio_input; /* current audio input */ |
| 645 | u32 active_input; /* current video input */ |
| 646 | u32 active_output; /* current video output */ |
| 647 | v4l2_std_id std; /* current capture TV standard */ |
| 648 | v4l2_std_id std_out; /* current TV output standard */ |
| 649 | u8 audio_stereo_mode; /* decoder setting how to handle stereo MPEG audio */ |
| 650 | u8 audio_bilingual_mode; /* decoder setting how to handle bilingual MPEG audio */ |
| 651 | struct cx2341x_mpeg_params params; /* current encoder parameters */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 652 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 653 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 654 | /* Locking */ |
| 655 | spinlock_t lock; /* lock access to this struct */ |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 656 | struct mutex serialize_lock; /* mutex used to serialize open/close/start/stop/ioctl operations */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 657 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 658 | /* Streams */ |
| 659 | int stream_buf_size[IVTV_MAX_STREAMS]; /* stream buffer size */ |
| 660 | struct ivtv_stream streams[IVTV_MAX_STREAMS]; /* stream data */ |
| 661 | atomic_t capturing; /* count number of active capture streams */ |
| 662 | atomic_t decoding; /* count number of active decoding streams */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 663 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 664 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 665 | /* Interrupts & DMA */ |
| 666 | u32 irqmask; /* active interrupts */ |
| 667 | u32 irq_rr_idx; /* round-robin stream index */ |
Tejun Heo | 7bc4656 | 2010-06-29 10:07:09 +0200 | [diff] [blame] | 668 | struct kthread_worker irq_worker; /* kthread worker for PIO/YUV/VBI actions */ |
| 669 | struct task_struct *irq_worker_task; /* task for irq_worker */ |
| 670 | struct kthread_work irq_work; /* kthread work entry */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 671 | spinlock_t dma_reg_lock; /* lock access to DMA engine registers */ |
| 672 | int cur_dma_stream; /* index of current stream doing DMA (-1 if none) */ |
| 673 | int cur_pio_stream; /* index of current stream doing PIO (-1 if none) */ |
| 674 | u32 dma_data_req_offset; /* store offset in decoder memory of current DMA request */ |
| 675 | u32 dma_data_req_size; /* store size of current DMA request */ |
| 676 | int dma_retries; /* current DMA retry attempt */ |
| 677 | struct ivtv_user_dma udma; /* user based DMA for OSD */ |
| 678 | struct timer_list dma_timer; /* timer used to catch unfinished DMAs */ |
Hans Verkuil | a158f35 | 2007-08-23 11:31:57 -0300 | [diff] [blame] | 679 | u32 last_vsync_field; /* last seen vsync field */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 680 | wait_queue_head_t dma_waitq; /* wake up when the current DMA is finished */ |
| 681 | wait_queue_head_t eos_waitq; /* wake up when EOS arrives */ |
| 682 | wait_queue_head_t event_waitq; /* wake up when the next decoder event arrives */ |
| 683 | wait_queue_head_t vsync_waitq; /* wake up when the next decoder vsync arrives */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 684 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 685 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 686 | /* Mailbox */ |
| 687 | struct ivtv_mailbox_data enc_mbox; /* encoder mailboxes */ |
| 688 | struct ivtv_mailbox_data dec_mbox; /* decoder mailboxes */ |
| 689 | struct ivtv_api_cache api_cache[256]; /* cached API commands */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 690 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 691 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 692 | /* I2C */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 693 | struct i2c_adapter i2c_adap; |
| 694 | struct i2c_algo_bit_data i2c_algo; |
| 695 | struct i2c_client i2c_client; |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 696 | int i2c_state; /* i2c bit state */ |
| 697 | struct mutex i2c_bus_lock; /* lock i2c bus */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 698 | |
Andy Walls | ad2fe2d | 2009-11-21 12:52:34 -0300 | [diff] [blame] | 699 | struct IR_i2c_init_data ir_i2c_init_data; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 700 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 701 | /* Program Index information */ |
| 702 | u32 pgm_info_offset; /* start of pgm info in encoder memory */ |
| 703 | u32 pgm_info_num; /* number of elements in the pgm cyclic buffer in encoder memory */ |
| 704 | u32 pgm_info_write_idx; /* last index written by the card that was transferred to pgm_info[] */ |
| 705 | u32 pgm_info_read_idx; /* last index in pgm_info read by the application */ |
| 706 | struct v4l2_enc_idx_entry pgm_info[IVTV_MAX_PGM_INDEX]; /* filled from the pgm cyclic buffer on the card */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 707 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 708 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 709 | /* Miscellaneous */ |
| 710 | u32 open_id; /* incremented each time an open occurs, is >= 1 */ |
| 711 | struct v4l2_prio_state prio; /* priority state */ |
| 712 | int search_pack_header; /* 1 if ivtv_copy_buf_to_user() is scanning for a pack header (0xba) */ |
| 713 | int speed; /* current playback speed setting */ |
| 714 | u8 speed_mute_audio; /* 1 if audio should be muted when fast forward */ |
| 715 | u64 mpg_data_received; /* number of bytes received from the MPEG stream */ |
| 716 | u64 vbi_data_inserted; /* number of VBI bytes inserted into the MPEG stream */ |
| 717 | u32 last_dec_timing[3]; /* cache last retrieved pts/scr/frame values */ |
| 718 | unsigned long dualwatch_jiffies;/* jiffies value of the previous dualwatch check */ |
Andy Walls | 0d82fe8 | 2009-01-01 19:02:31 -0300 | [diff] [blame] | 719 | u32 dualwatch_stereo_mode; /* current detected dualwatch stereo mode */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 720 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 721 | |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 722 | /* VBI state info */ |
| 723 | struct vbi_info vbi; /* VBI-specific data */ |
| 724 | |
| 725 | |
| 726 | /* YUV playback */ |
| 727 | struct yuv_playback_info yuv_info; /* YUV playback data */ |
| 728 | |
| 729 | |
| 730 | /* OSD support */ |
| 731 | unsigned long osd_video_pbase; |
| 732 | int osd_global_alpha_state; /* 1 = global alpha is on */ |
| 733 | int osd_local_alpha_state; /* 1 = local alpha is on */ |
| 734 | int osd_chroma_key_state; /* 1 = chroma-keying is on */ |
| 735 | u8 osd_global_alpha; /* current global alpha */ |
| 736 | u32 osd_chroma_key; /* current chroma key */ |
Hans Verkuil | fd8b281 | 2007-08-23 10:13:15 -0300 | [diff] [blame] | 737 | struct v4l2_rect osd_rect; /* current OSD position and size */ |
| 738 | struct v4l2_rect main_rect; /* current Main window position and size */ |
Hans Verkuil | 7b3a0d4 | 2007-08-26 06:11:07 -0300 | [diff] [blame] | 739 | struct osd_info *osd_info; /* ivtvfb private OSD info */ |
Ian Armstrong | 215659d | 2010-06-12 13:41:57 -0300 | [diff] [blame] | 740 | void (*ivtvfb_restore)(struct ivtv *itv); /* Used for a warm start */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 741 | }; |
| 742 | |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 743 | static inline struct ivtv *to_ivtv(struct v4l2_device *v4l2_dev) |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 744 | { |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 745 | return container_of(v4l2_dev, struct ivtv, v4l2_dev); |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 746 | } |
| 747 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 748 | /* Globals */ |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 749 | extern int ivtv_first_minor; |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 750 | |
| 751 | /*==============Prototypes==================*/ |
| 752 | |
| 753 | /* Hardware/IRQ */ |
| 754 | void ivtv_set_irq_mask(struct ivtv *itv, u32 mask); |
| 755 | void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask); |
| 756 | |
| 757 | /* try to set output mode, return current mode. */ |
| 758 | int ivtv_set_output_mode(struct ivtv *itv, int mode); |
| 759 | |
| 760 | /* return current output stream based on current mode */ |
| 761 | struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv); |
| 762 | |
| 763 | /* Return non-zero if a signal is pending */ |
Mauro Carvalho Chehab | 201700d | 2007-07-19 11:21:04 -0300 | [diff] [blame] | 764 | int ivtv_msleep_timeout(unsigned int msecs, int intr); |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 765 | |
| 766 | /* Wait on queue, returns -EINTR if interrupted */ |
| 767 | int ivtv_waitq(wait_queue_head_t *waitq); |
| 768 | |
| 769 | /* Read Hauppauge eeprom */ |
| 770 | struct tveeprom; /* forward reference */ |
| 771 | void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv); |
| 772 | |
Hans Verkuil | c976bc8 | 2007-07-22 12:52:40 -0300 | [diff] [blame] | 773 | /* First-open initialization: load firmware, init cx25840, etc. */ |
| 774 | int ivtv_init_on_first_open(struct ivtv *itv); |
| 775 | |
Hans Verkuil | a8b8643 | 2008-10-04 08:05:30 -0300 | [diff] [blame] | 776 | /* Test if the current VBI mode is raw (1) or sliced (0) */ |
| 777 | static inline int ivtv_raw_vbi(const struct ivtv *itv) |
| 778 | { |
| 779 | return itv->vbi.in.type == V4L2_BUF_TYPE_VBI_CAPTURE; |
| 780 | } |
| 781 | |
Hans Verkuil | 1a0adaf | 2007-04-27 12:31:25 -0300 | [diff] [blame] | 782 | /* This is a PCI post thing, where if the pci register is not read, then |
| 783 | the write doesn't always take effect right away. By reading back the |
| 784 | register any pending PCI writes will be performed (in order), and so |
| 785 | you can be sure that the writes are guaranteed to be done. |
| 786 | |
| 787 | Rarely needed, only in some timing sensitive cases. |
| 788 | Apparently if this is not done some motherboards seem |
| 789 | to kill the firmware and get into the broken state until computer is |
| 790 | rebooted. */ |
| 791 | #define write_sync(val, reg) \ |
| 792 | do { writel(val, reg); readl(reg); } while (0) |
| 793 | |
| 794 | #define read_reg(reg) readl(itv->reg_mem + (reg)) |
| 795 | #define write_reg(val, reg) writel(val, itv->reg_mem + (reg)) |
| 796 | #define write_reg_sync(val, reg) \ |
| 797 | do { write_reg(val, reg); read_reg(reg); } while (0) |
| 798 | |
| 799 | #define read_enc(addr) readl(itv->enc_mem + (u32)(addr)) |
| 800 | #define write_enc(val, addr) writel(val, itv->enc_mem + (u32)(addr)) |
| 801 | #define write_enc_sync(val, addr) \ |
| 802 | do { write_enc(val, addr); read_enc(addr); } while (0) |
| 803 | |
| 804 | #define read_dec(addr) readl(itv->dec_mem + (u32)(addr)) |
| 805 | #define write_dec(val, addr) writel(val, itv->dec_mem + (u32)(addr)) |
| 806 | #define write_dec_sync(val, addr) \ |
| 807 | do { write_dec(val, addr); read_dec(addr); } while (0) |
| 808 | |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 809 | /* Call the specified callback for all subdevs matching hw (if 0, then |
| 810 | match them all). Ignore any errors. */ |
| 811 | #define ivtv_call_hw(itv, hw, o, f, args...) \ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 812 | __v4l2_device_call_subdevs(&(itv)->v4l2_dev, !(hw) || (sd->grp_id & (hw)), o, f , ##args) |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 813 | |
| 814 | #define ivtv_call_all(itv, o, f, args...) ivtv_call_hw(itv, 0, o, f , ##args) |
| 815 | |
| 816 | /* Call the specified callback for all subdevs matching hw (if 0, then |
| 817 | match them all). If the callback returns an error other than 0 or |
| 818 | -ENOIOCTLCMD, then return with that error code. */ |
| 819 | #define ivtv_call_hw_err(itv, hw, o, f, args...) \ |
Hans Verkuil | 8ac05ae | 2009-02-07 07:02:27 -0300 | [diff] [blame] | 820 | __v4l2_device_call_subdevs_until_err(&(itv)->v4l2_dev, !(hw) || (sd->grp_id & (hw)), o, f , ##args) |
Hans Verkuil | 67ec09f | 2008-11-29 19:38:23 -0300 | [diff] [blame] | 821 | |
| 822 | #define ivtv_call_all_err(itv, o, f, args...) ivtv_call_hw_err(itv, 0, o, f , ##args) |
| 823 | |
Hans Verkuil | 612570f | 2007-08-23 05:42:59 -0300 | [diff] [blame] | 824 | #endif |