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>
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.
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.
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
24 #include "ivtv-driver.h"
25 #include "ivtv-mailbox.h"
27 /* Firmware mailbox flags*/
28 #define IVTV_MBOX_FIRMWARE_DONE 0x00000004
29 #define IVTV_MBOX_DRIVER_DONE 0x00000002
30 #define IVTV_MBOX_DRIVER_BUSY 0x00000001
31 #define IVTV_MBOX_FREE 0x00000000
33 /* Firmware mailbox standard timeout */
34 #define IVTV_API_STD_TIMEOUT 0x02000000
36 #define API_CACHE (1 << 0) /* Allow the command to be stored in the cache */
37 #define API_RESULT (1 << 1) /* Allow 1 second for this cmd to end */
38 #define API_FAST_RESULT (3 << 1) /* Allow 0.1 second for this cmd to end */
39 #define API_DMA (1 << 3) /* DMA mailbox, has special handling */
40 #define API_HIGH_VOL (1 << 5) /* High volume command (i.e. called during encoding or decoding) */
41 #define API_NO_WAIT_MB (1 << 4) /* Command may not wait for a free mailbox */
42 #define API_NO_WAIT_RES (1 << 5) /* Command may not wait for the result */
43 #define API_NO_POLL (1 << 6) /* Avoid pointless polling */
45 struct ivtv_api_info
{
46 int flags
; /* Flags, see above */
47 const char *name
; /* The name of the command */
50 #define API_ENTRY(x, f) [x] = { (f), #x }
52 static const struct ivtv_api_info api_info
[256] = {
53 /* MPEG encoder API */
54 API_ENTRY(CX2341X_ENC_PING_FW
, API_FAST_RESULT
),
55 API_ENTRY(CX2341X_ENC_START_CAPTURE
, API_RESULT
| API_NO_POLL
),
56 API_ENTRY(CX2341X_ENC_STOP_CAPTURE
, API_RESULT
),
57 API_ENTRY(CX2341X_ENC_SET_AUDIO_ID
, API_CACHE
),
58 API_ENTRY(CX2341X_ENC_SET_VIDEO_ID
, API_CACHE
),
59 API_ENTRY(CX2341X_ENC_SET_PCR_ID
, API_CACHE
),
60 API_ENTRY(CX2341X_ENC_SET_FRAME_RATE
, API_CACHE
),
61 API_ENTRY(CX2341X_ENC_SET_FRAME_SIZE
, API_CACHE
),
62 API_ENTRY(CX2341X_ENC_SET_BIT_RATE
, API_CACHE
),
63 API_ENTRY(CX2341X_ENC_SET_GOP_PROPERTIES
, API_CACHE
),
64 API_ENTRY(CX2341X_ENC_SET_ASPECT_RATIO
, API_CACHE
),
65 API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_MODE
, API_CACHE
),
66 API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_PROPS
, API_CACHE
),
67 API_ENTRY(CX2341X_ENC_SET_CORING_LEVELS
, API_CACHE
),
68 API_ENTRY(CX2341X_ENC_SET_SPATIAL_FILTER_TYPE
, API_CACHE
),
69 API_ENTRY(CX2341X_ENC_SET_VBI_LINE
, API_RESULT
),
70 API_ENTRY(CX2341X_ENC_SET_STREAM_TYPE
, API_CACHE
),
71 API_ENTRY(CX2341X_ENC_SET_OUTPUT_PORT
, API_CACHE
),
72 API_ENTRY(CX2341X_ENC_SET_AUDIO_PROPERTIES
, API_CACHE
),
73 API_ENTRY(CX2341X_ENC_HALT_FW
, API_FAST_RESULT
),
74 API_ENTRY(CX2341X_ENC_GET_VERSION
, API_FAST_RESULT
),
75 API_ENTRY(CX2341X_ENC_SET_GOP_CLOSURE
, API_CACHE
),
76 API_ENTRY(CX2341X_ENC_GET_SEQ_END
, API_RESULT
),
77 API_ENTRY(CX2341X_ENC_SET_PGM_INDEX_INFO
, API_FAST_RESULT
),
78 API_ENTRY(CX2341X_ENC_SET_VBI_CONFIG
, API_RESULT
),
79 API_ENTRY(CX2341X_ENC_SET_DMA_BLOCK_SIZE
, API_CACHE
),
80 API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_10
, API_FAST_RESULT
),
81 API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_9
, API_FAST_RESULT
),
82 API_ENTRY(CX2341X_ENC_SCHED_DMA_TO_HOST
, API_DMA
| API_HIGH_VOL
),
83 API_ENTRY(CX2341X_ENC_INITIALIZE_INPUT
, API_RESULT
),
84 API_ENTRY(CX2341X_ENC_SET_FRAME_DROP_RATE
, API_CACHE
),
85 API_ENTRY(CX2341X_ENC_PAUSE_ENCODER
, API_RESULT
),
86 API_ENTRY(CX2341X_ENC_REFRESH_INPUT
, API_NO_WAIT_MB
| API_HIGH_VOL
),
87 API_ENTRY(CX2341X_ENC_SET_COPYRIGHT
, API_CACHE
),
88 API_ENTRY(CX2341X_ENC_SET_EVENT_NOTIFICATION
, API_RESULT
),
89 API_ENTRY(CX2341X_ENC_SET_NUM_VSYNC_LINES
, API_CACHE
),
90 API_ENTRY(CX2341X_ENC_SET_PLACEHOLDER
, API_CACHE
),
91 API_ENTRY(CX2341X_ENC_MUTE_VIDEO
, API_RESULT
),
92 API_ENTRY(CX2341X_ENC_MUTE_AUDIO
, API_RESULT
),
93 API_ENTRY(CX2341X_ENC_SET_VERT_CROP_LINE
, API_FAST_RESULT
),
94 API_ENTRY(CX2341X_ENC_MISC
, API_FAST_RESULT
),
95 /* Obsolete PULLDOWN API command */
96 API_ENTRY(0xb1, API_CACHE
),
98 /* MPEG decoder API */
99 API_ENTRY(CX2341X_DEC_PING_FW
, API_FAST_RESULT
),
100 API_ENTRY(CX2341X_DEC_START_PLAYBACK
, API_RESULT
| API_NO_POLL
),
101 API_ENTRY(CX2341X_DEC_STOP_PLAYBACK
, API_RESULT
),
102 API_ENTRY(CX2341X_DEC_SET_PLAYBACK_SPEED
, API_RESULT
),
103 API_ENTRY(CX2341X_DEC_STEP_VIDEO
, API_RESULT
),
104 API_ENTRY(CX2341X_DEC_SET_DMA_BLOCK_SIZE
, API_CACHE
),
105 API_ENTRY(CX2341X_DEC_GET_XFER_INFO
, API_FAST_RESULT
),
106 API_ENTRY(CX2341X_DEC_GET_DMA_STATUS
, API_FAST_RESULT
),
107 API_ENTRY(CX2341X_DEC_SCHED_DMA_FROM_HOST
, API_DMA
| API_HIGH_VOL
),
108 API_ENTRY(CX2341X_DEC_PAUSE_PLAYBACK
, API_RESULT
),
109 API_ENTRY(CX2341X_DEC_HALT_FW
, API_FAST_RESULT
),
110 API_ENTRY(CX2341X_DEC_SET_STANDARD
, API_CACHE
),
111 API_ENTRY(CX2341X_DEC_GET_VERSION
, API_FAST_RESULT
),
112 API_ENTRY(CX2341X_DEC_SET_STREAM_INPUT
, API_CACHE
),
113 API_ENTRY(CX2341X_DEC_GET_TIMING_INFO
, API_RESULT
/*| API_NO_WAIT_RES*/),
114 API_ENTRY(CX2341X_DEC_SET_AUDIO_MODE
, API_CACHE
),
115 API_ENTRY(CX2341X_DEC_SET_EVENT_NOTIFICATION
, API_RESULT
),
116 API_ENTRY(CX2341X_DEC_SET_DISPLAY_BUFFERS
, API_CACHE
),
117 API_ENTRY(CX2341X_DEC_EXTRACT_VBI
, API_RESULT
),
118 API_ENTRY(CX2341X_DEC_SET_DECODER_SOURCE
, API_FAST_RESULT
),
119 API_ENTRY(CX2341X_DEC_SET_PREBUFFERING
, API_CACHE
),
122 API_ENTRY(CX2341X_OSD_GET_FRAMEBUFFER
, API_FAST_RESULT
),
123 API_ENTRY(CX2341X_OSD_GET_PIXEL_FORMAT
, API_FAST_RESULT
),
124 API_ENTRY(CX2341X_OSD_SET_PIXEL_FORMAT
, API_CACHE
),
125 API_ENTRY(CX2341X_OSD_GET_STATE
, API_FAST_RESULT
),
126 API_ENTRY(CX2341X_OSD_SET_STATE
, API_CACHE
),
127 API_ENTRY(CX2341X_OSD_GET_OSD_COORDS
, API_FAST_RESULT
),
128 API_ENTRY(CX2341X_OSD_SET_OSD_COORDS
, API_CACHE
),
129 API_ENTRY(CX2341X_OSD_GET_SCREEN_COORDS
, API_FAST_RESULT
),
130 API_ENTRY(CX2341X_OSD_SET_SCREEN_COORDS
, API_CACHE
),
131 API_ENTRY(CX2341X_OSD_GET_GLOBAL_ALPHA
, API_FAST_RESULT
),
132 API_ENTRY(CX2341X_OSD_SET_GLOBAL_ALPHA
, API_CACHE
),
133 API_ENTRY(CX2341X_OSD_SET_BLEND_COORDS
, API_CACHE
),
134 API_ENTRY(CX2341X_OSD_GET_FLICKER_STATE
, API_FAST_RESULT
),
135 API_ENTRY(CX2341X_OSD_SET_FLICKER_STATE
, API_CACHE
),
136 API_ENTRY(CX2341X_OSD_BLT_COPY
, API_RESULT
),
137 API_ENTRY(CX2341X_OSD_BLT_FILL
, API_RESULT
),
138 API_ENTRY(CX2341X_OSD_BLT_TEXT
, API_RESULT
),
139 API_ENTRY(CX2341X_OSD_SET_FRAMEBUFFER_WINDOW
, API_CACHE
),
140 API_ENTRY(CX2341X_OSD_SET_CHROMA_KEY
, API_CACHE
),
141 API_ENTRY(CX2341X_OSD_GET_ALPHA_CONTENT_INDEX
, API_FAST_RESULT
),
142 API_ENTRY(CX2341X_OSD_SET_ALPHA_CONTENT_INDEX
, API_CACHE
)
145 static int try_mailbox(struct ivtv
*itv
, struct ivtv_mailbox_data
*mbdata
, int mb
)
147 u32 flags
= readl(&mbdata
->mbox
[mb
].flags
);
148 int is_free
= flags
== IVTV_MBOX_FREE
|| (flags
& IVTV_MBOX_FIRMWARE_DONE
);
150 /* if the mailbox is free, then try to claim it */
151 if (is_free
&& !test_and_set_bit(mb
, &mbdata
->busy
)) {
152 write_sync(IVTV_MBOX_DRIVER_BUSY
, &mbdata
->mbox
[mb
].flags
);
158 /* Try to find a free mailbox. Note mailbox 0 is reserved for DMA and so is not
160 static int get_mailbox(struct ivtv
*itv
, struct ivtv_mailbox_data
*mbdata
, int flags
)
162 unsigned long then
= jiffies
;
164 int max_mbox
= mbdata
->max_mbox
;
167 /* All slow commands use the same mailbox, serializing them and also
168 leaving the other mailbox free for simple fast commands. */
169 if ((flags
& API_FAST_RESULT
) == API_RESULT
)
172 /* find free non-DMA mailbox */
173 for (i
= 0; i
< retries
; i
++) {
174 for (mb
= 1; mb
<= max_mbox
; mb
++)
175 if (try_mailbox(itv
, mbdata
, mb
))
178 /* Sleep before a retry, if not atomic */
179 if (!(flags
& API_NO_WAIT_MB
)) {
180 if (jiffies
- then
> msecs_to_jiffies(10*retries
))
182 ivtv_msleep_timeout(10, 0);
188 static void write_mailbox(volatile struct ivtv_mailbox __iomem
*mbox
, int cmd
, int args
, u32 data
[])
192 write_sync(cmd
, &mbox
->cmd
);
193 write_sync(IVTV_API_STD_TIMEOUT
, &mbox
->timeout
);
195 for (i
= 0; i
< CX2341X_MBOX_MAX_DATA
; i
++)
196 write_sync(data
[i
], &mbox
->data
[i
]);
198 write_sync(IVTV_MBOX_DRIVER_DONE
| IVTV_MBOX_DRIVER_BUSY
, &mbox
->flags
);
201 static void clear_all_mailboxes(struct ivtv
*itv
, struct ivtv_mailbox_data
*mbdata
)
205 for (i
= 0; i
<= mbdata
->max_mbox
; i
++) {
206 IVTV_DEBUG_WARN("Clearing mailbox %d: cmd 0x%08x flags 0x%08x\n",
207 i
, readl(&mbdata
->mbox
[i
].cmd
), readl(&mbdata
->mbox
[i
].flags
));
208 write_sync(0, &mbdata
->mbox
[i
].flags
);
209 clear_bit(i
, &mbdata
->busy
);
213 static int ivtv_api_call(struct ivtv
*itv
, int cmd
, int args
, u32 data
[])
215 struct ivtv_mailbox_data
*mbdata
= (cmd
>= 128) ? &itv
->enc_mbox
: &itv
->dec_mbox
;
216 volatile struct ivtv_mailbox __iomem
*mbox
;
217 int api_timeout
= msecs_to_jiffies(1000);
222 if (NULL
== mbdata
) {
223 IVTV_ERR("No mailbox allocated\n");
226 if (args
< 0 || args
> CX2341X_MBOX_MAX_DATA
||
227 cmd
< 0 || cmd
> 255 || api_info
[cmd
].name
== NULL
) {
228 IVTV_ERR("Invalid MB call: cmd = 0x%02x, args = %d\n", cmd
, args
);
232 if (api_info
[cmd
].flags
& API_HIGH_VOL
) {
233 IVTV_DEBUG_HI_MB("MB Call: %s\n", api_info
[cmd
].name
);
236 IVTV_DEBUG_MB("MB Call: %s\n", api_info
[cmd
].name
);
239 /* clear possibly uninitialized part of data array */
240 for (i
= args
; i
< CX2341X_MBOX_MAX_DATA
; i
++)
243 /* If this command was issued within the last 30 minutes and with identical
244 data, then just return 0 as there is no need to issue this command again.
245 Just an optimization to prevent unnecessary use of mailboxes. */
246 if (itv
->api_cache
[cmd
].last_jiffies
&&
247 jiffies
- itv
->api_cache
[cmd
].last_jiffies
< msecs_to_jiffies(1800000) &&
248 !memcmp(data
, itv
->api_cache
[cmd
].data
, sizeof(itv
->api_cache
[cmd
].data
))) {
249 itv
->api_cache
[cmd
].last_jiffies
= jiffies
;
253 flags
= api_info
[cmd
].flags
;
255 if (flags
& API_DMA
) {
256 for (i
= 0; i
< 100; i
++) {
257 mb
= i
% (mbdata
->max_mbox
+ 1);
258 if (try_mailbox(itv
, mbdata
, mb
)) {
259 write_mailbox(&mbdata
->mbox
[mb
], cmd
, args
, data
);
260 clear_bit(mb
, &mbdata
->busy
);
263 IVTV_DEBUG_WARN("%s: mailbox %d not free %08x\n",
264 api_info
[cmd
].name
, mb
, readl(&mbdata
->mbox
[mb
].flags
));
266 IVTV_WARN("Could not find free DMA mailbox for %s\n", api_info
[cmd
].name
);
267 clear_all_mailboxes(itv
, mbdata
);
271 if ((flags
& API_FAST_RESULT
) == API_FAST_RESULT
)
272 api_timeout
= msecs_to_jiffies(100);
274 mb
= get_mailbox(itv
, mbdata
, flags
);
276 IVTV_DEBUG_WARN("No free mailbox found (%s)\n", api_info
[cmd
].name
);
277 clear_all_mailboxes(itv
, mbdata
);
280 mbox
= &mbdata
->mbox
[mb
];
281 write_mailbox(mbox
, cmd
, args
, data
);
282 if (flags
& API_CACHE
) {
283 memcpy(itv
->api_cache
[cmd
].data
, data
, sizeof(itv
->api_cache
[cmd
].data
));
284 itv
->api_cache
[cmd
].last_jiffies
= jiffies
;
286 if ((flags
& API_RESULT
) == 0) {
287 clear_bit(mb
, &mbdata
->busy
);
294 if (!(flags
& API_NO_POLL
)) {
295 /* First try to poll, then switch to delays */
296 for (i
= 0; i
< 100; i
++) {
297 if (readl(&mbox
->flags
) & IVTV_MBOX_FIRMWARE_DONE
)
301 while (!(readl(&mbox
->flags
) & IVTV_MBOX_FIRMWARE_DONE
)) {
302 if (jiffies
- then
> api_timeout
) {
303 IVTV_DEBUG_WARN("Could not get result (%s)\n", api_info
[cmd
].name
);
304 /* reset the mailbox, but it is likely too late already */
305 write_sync(0, &mbox
->flags
);
306 clear_bit(mb
, &mbdata
->busy
);
309 if (flags
& API_NO_WAIT_RES
)
312 ivtv_msleep_timeout(1, 0);
314 if (jiffies
- then
> msecs_to_jiffies(100))
315 IVTV_DEBUG_WARN("%s took %u jiffies\n",
317 jiffies_to_msecs(jiffies
- then
));
319 for (i
= 0; i
< CX2341X_MBOX_MAX_DATA
; i
++)
320 data
[i
] = readl(&mbox
->data
[i
]);
321 write_sync(0, &mbox
->flags
);
322 clear_bit(mb
, &mbdata
->busy
);
326 int ivtv_api(struct ivtv
*itv
, int cmd
, int args
, u32 data
[])
328 int res
= ivtv_api_call(itv
, cmd
, args
, data
);
330 /* Allow a single retry, probably already too late though.
331 If there is no free mailbox then that is usually an indication
332 of a more serious problem. */
333 return (res
== -EBUSY
) ? ivtv_api_call(itv
, cmd
, args
, data
) : res
;
336 int ivtv_api_func(void *priv
, int cmd
, int in
, int out
, u32 data
[CX2341X_MBOX_MAX_DATA
])
338 return ivtv_api(priv
, cmd
, in
, data
);
341 int ivtv_vapi_result(struct ivtv
*itv
, u32 data
[CX2341X_MBOX_MAX_DATA
], int cmd
, int args
, ...)
347 for (i
= 0; i
< args
; i
++) {
348 data
[i
] = va_arg(ap
, u32
);
351 return ivtv_api(itv
, cmd
, args
, data
);
354 int ivtv_vapi(struct ivtv
*itv
, int cmd
, int args
, ...)
356 u32 data
[CX2341X_MBOX_MAX_DATA
];
361 for (i
= 0; i
< args
; i
++) {
362 data
[i
] = va_arg(ap
, u32
);
365 return ivtv_api(itv
, cmd
, args
, data
);
368 /* This one is for stuff that can't sleep.. irq handlers, etc.. */
369 void ivtv_api_get_data(struct ivtv_mailbox_data
*mbdata
, int mb
, u32 data
[])
373 for (i
= 0; i
< CX2341X_MBOX_MAX_DATA
; i
++)
374 data
[i
] = readl(&mbdata
->mbox
[mb
].data
[i
]);