1
2
3
4
5
6
7
8
9
10#include "ivtv-driver.h"
11#include "ivtv-mailbox.h"
12
13
14#define IVTV_MBOX_FIRMWARE_DONE 0x00000004
15#define IVTV_MBOX_DRIVER_DONE 0x00000002
16#define IVTV_MBOX_DRIVER_BUSY 0x00000001
17#define IVTV_MBOX_FREE 0x00000000
18
19
20#define IVTV_API_STD_TIMEOUT 0x02000000
21
22#define API_CACHE (1 << 0)
23#define API_RESULT (1 << 1)
24#define API_FAST_RESULT (3 << 1)
25#define API_DMA (1 << 3)
26#define API_HIGH_VOL (1 << 5)
27#define API_NO_WAIT_MB (1 << 4)
28#define API_NO_WAIT_RES (1 << 5)
29#define API_NO_POLL (1 << 6)
30
31struct ivtv_api_info {
32 int flags;
33 const char *name;
34};
35
36#define API_ENTRY(x, f) [x] = { (f), #x }
37
38static const struct ivtv_api_info api_info[256] = {
39
40 API_ENTRY(CX2341X_ENC_PING_FW, API_FAST_RESULT),
41 API_ENTRY(CX2341X_ENC_START_CAPTURE, API_RESULT | API_NO_POLL),
42 API_ENTRY(CX2341X_ENC_STOP_CAPTURE, API_RESULT),
43 API_ENTRY(CX2341X_ENC_SET_AUDIO_ID, API_CACHE),
44 API_ENTRY(CX2341X_ENC_SET_VIDEO_ID, API_CACHE),
45 API_ENTRY(CX2341X_ENC_SET_PCR_ID, API_CACHE),
46 API_ENTRY(CX2341X_ENC_SET_FRAME_RATE, API_CACHE),
47 API_ENTRY(CX2341X_ENC_SET_FRAME_SIZE, API_CACHE),
48 API_ENTRY(CX2341X_ENC_SET_BIT_RATE, API_CACHE),
49 API_ENTRY(CX2341X_ENC_SET_GOP_PROPERTIES, API_CACHE),
50 API_ENTRY(CX2341X_ENC_SET_ASPECT_RATIO, API_CACHE),
51 API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_MODE, API_CACHE),
52 API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_PROPS, API_CACHE),
53 API_ENTRY(CX2341X_ENC_SET_CORING_LEVELS, API_CACHE),
54 API_ENTRY(CX2341X_ENC_SET_SPATIAL_FILTER_TYPE, API_CACHE),
55 API_ENTRY(CX2341X_ENC_SET_VBI_LINE, API_RESULT),
56 API_ENTRY(CX2341X_ENC_SET_STREAM_TYPE, API_CACHE),
57 API_ENTRY(CX2341X_ENC_SET_OUTPUT_PORT, API_CACHE),
58 API_ENTRY(CX2341X_ENC_SET_AUDIO_PROPERTIES, API_CACHE),
59 API_ENTRY(CX2341X_ENC_HALT_FW, API_FAST_RESULT),
60 API_ENTRY(CX2341X_ENC_GET_VERSION, API_FAST_RESULT),
61 API_ENTRY(CX2341X_ENC_SET_GOP_CLOSURE, API_CACHE),
62 API_ENTRY(CX2341X_ENC_GET_SEQ_END, API_RESULT),
63 API_ENTRY(CX2341X_ENC_SET_PGM_INDEX_INFO, API_FAST_RESULT),
64 API_ENTRY(CX2341X_ENC_SET_VBI_CONFIG, API_RESULT),
65 API_ENTRY(CX2341X_ENC_SET_DMA_BLOCK_SIZE, API_CACHE),
66 API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_10, API_FAST_RESULT),
67 API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_9, API_FAST_RESULT),
68 API_ENTRY(CX2341X_ENC_SCHED_DMA_TO_HOST, API_DMA | API_HIGH_VOL),
69 API_ENTRY(CX2341X_ENC_INITIALIZE_INPUT, API_RESULT),
70 API_ENTRY(CX2341X_ENC_SET_FRAME_DROP_RATE, API_CACHE),
71 API_ENTRY(CX2341X_ENC_PAUSE_ENCODER, API_RESULT),
72 API_ENTRY(CX2341X_ENC_REFRESH_INPUT, API_NO_WAIT_MB | API_HIGH_VOL),
73 API_ENTRY(CX2341X_ENC_SET_COPYRIGHT, API_CACHE),
74 API_ENTRY(CX2341X_ENC_SET_EVENT_NOTIFICATION, API_RESULT),
75 API_ENTRY(CX2341X_ENC_SET_NUM_VSYNC_LINES, API_CACHE),
76 API_ENTRY(CX2341X_ENC_SET_PLACEHOLDER, API_CACHE),
77 API_ENTRY(CX2341X_ENC_MUTE_VIDEO, API_RESULT),
78 API_ENTRY(CX2341X_ENC_MUTE_AUDIO, API_RESULT),
79 API_ENTRY(CX2341X_ENC_SET_VERT_CROP_LINE, API_FAST_RESULT),
80 API_ENTRY(CX2341X_ENC_MISC, API_FAST_RESULT),
81
82 API_ENTRY(0xb1, API_CACHE),
83
84
85 API_ENTRY(CX2341X_DEC_PING_FW, API_FAST_RESULT),
86 API_ENTRY(CX2341X_DEC_START_PLAYBACK, API_RESULT | API_NO_POLL),
87 API_ENTRY(CX2341X_DEC_STOP_PLAYBACK, API_RESULT),
88 API_ENTRY(CX2341X_DEC_SET_PLAYBACK_SPEED, API_RESULT),
89 API_ENTRY(CX2341X_DEC_STEP_VIDEO, API_RESULT),
90 API_ENTRY(CX2341X_DEC_SET_DMA_BLOCK_SIZE, API_CACHE),
91 API_ENTRY(CX2341X_DEC_GET_XFER_INFO, API_FAST_RESULT),
92 API_ENTRY(CX2341X_DEC_GET_DMA_STATUS, API_FAST_RESULT),
93 API_ENTRY(CX2341X_DEC_SCHED_DMA_FROM_HOST, API_DMA | API_HIGH_VOL),
94 API_ENTRY(CX2341X_DEC_PAUSE_PLAYBACK, API_RESULT),
95 API_ENTRY(CX2341X_DEC_HALT_FW, API_FAST_RESULT),
96 API_ENTRY(CX2341X_DEC_SET_STANDARD, API_CACHE),
97 API_ENTRY(CX2341X_DEC_GET_VERSION, API_FAST_RESULT),
98 API_ENTRY(CX2341X_DEC_SET_STREAM_INPUT, API_CACHE),
99 API_ENTRY(CX2341X_DEC_GET_TIMING_INFO, API_RESULT ),
100 API_ENTRY(CX2341X_DEC_SET_AUDIO_MODE, API_CACHE),
101 API_ENTRY(CX2341X_DEC_SET_EVENT_NOTIFICATION, API_RESULT),
102 API_ENTRY(CX2341X_DEC_SET_DISPLAY_BUFFERS, API_CACHE),
103 API_ENTRY(CX2341X_DEC_EXTRACT_VBI, API_RESULT),
104 API_ENTRY(CX2341X_DEC_SET_DECODER_SOURCE, API_FAST_RESULT),
105 API_ENTRY(CX2341X_DEC_SET_PREBUFFERING, API_CACHE),
106
107
108 API_ENTRY(CX2341X_OSD_GET_FRAMEBUFFER, API_FAST_RESULT),
109 API_ENTRY(CX2341X_OSD_GET_PIXEL_FORMAT, API_FAST_RESULT),
110 API_ENTRY(CX2341X_OSD_SET_PIXEL_FORMAT, API_CACHE),
111 API_ENTRY(CX2341X_OSD_GET_STATE, API_FAST_RESULT),
112 API_ENTRY(CX2341X_OSD_SET_STATE, API_CACHE),
113 API_ENTRY(CX2341X_OSD_GET_OSD_COORDS, API_FAST_RESULT),
114 API_ENTRY(CX2341X_OSD_SET_OSD_COORDS, API_CACHE),
115 API_ENTRY(CX2341X_OSD_GET_SCREEN_COORDS, API_FAST_RESULT),
116 API_ENTRY(CX2341X_OSD_SET_SCREEN_COORDS, API_CACHE),
117 API_ENTRY(CX2341X_OSD_GET_GLOBAL_ALPHA, API_FAST_RESULT),
118 API_ENTRY(CX2341X_OSD_SET_GLOBAL_ALPHA, API_CACHE),
119 API_ENTRY(CX2341X_OSD_SET_BLEND_COORDS, API_CACHE),
120 API_ENTRY(CX2341X_OSD_GET_FLICKER_STATE, API_FAST_RESULT),
121 API_ENTRY(CX2341X_OSD_SET_FLICKER_STATE, API_CACHE),
122 API_ENTRY(CX2341X_OSD_BLT_COPY, API_RESULT),
123 API_ENTRY(CX2341X_OSD_BLT_FILL, API_RESULT),
124 API_ENTRY(CX2341X_OSD_BLT_TEXT, API_RESULT),
125 API_ENTRY(CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, API_CACHE),
126 API_ENTRY(CX2341X_OSD_SET_CHROMA_KEY, API_CACHE),
127 API_ENTRY(CX2341X_OSD_GET_ALPHA_CONTENT_INDEX, API_FAST_RESULT),
128 API_ENTRY(CX2341X_OSD_SET_ALPHA_CONTENT_INDEX, API_CACHE)
129};
130
131static int try_mailbox(struct ivtv *itv, struct ivtv_mailbox_data *mbdata, int mb)
132{
133 u32 flags = readl(&mbdata->mbox[mb].flags);
134 int is_free = flags == IVTV_MBOX_FREE || (flags & IVTV_MBOX_FIRMWARE_DONE);
135
136
137 if (is_free && !test_and_set_bit(mb, &mbdata->busy)) {
138 write_sync(IVTV_MBOX_DRIVER_BUSY, &mbdata->mbox[mb].flags);
139 return 1;
140 }
141 return 0;
142}
143
144
145
146static int get_mailbox(struct ivtv *itv, struct ivtv_mailbox_data *mbdata, int flags)
147{
148 unsigned long then = jiffies;
149 int i, mb;
150 int max_mbox = mbdata->max_mbox;
151 int retries = 100;
152
153
154
155 if ((flags & API_FAST_RESULT) == API_RESULT)
156 max_mbox = 1;
157
158
159 for (i = 0; i < retries; i++) {
160 for (mb = 1; mb <= max_mbox; mb++)
161 if (try_mailbox(itv, mbdata, mb))
162 return mb;
163
164
165 if (!(flags & API_NO_WAIT_MB)) {
166 if (time_after(jiffies,
167 then + msecs_to_jiffies(10*retries)))
168 break;
169 ivtv_msleep_timeout(10, 0);
170 }
171 }
172 return -ENODEV;
173}
174
175static void write_mailbox(volatile struct ivtv_mailbox __iomem *mbox, int cmd, int args, u32 data[])
176{
177 int i;
178
179 write_sync(cmd, &mbox->cmd);
180 write_sync(IVTV_API_STD_TIMEOUT, &mbox->timeout);
181
182 for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
183 write_sync(data[i], &mbox->data[i]);
184
185 write_sync(IVTV_MBOX_DRIVER_DONE | IVTV_MBOX_DRIVER_BUSY, &mbox->flags);
186}
187
188static void clear_all_mailboxes(struct ivtv *itv, struct ivtv_mailbox_data *mbdata)
189{
190 int i;
191
192 for (i = 0; i <= mbdata->max_mbox; i++) {
193 IVTV_DEBUG_WARN("Clearing mailbox %d: cmd 0x%08x flags 0x%08x\n",
194 i, readl(&mbdata->mbox[i].cmd), readl(&mbdata->mbox[i].flags));
195 write_sync(0, &mbdata->mbox[i].flags);
196 clear_bit(i, &mbdata->busy);
197 }
198}
199
200static int ivtv_api_call(struct ivtv *itv, int cmd, int args, u32 data[])
201{
202 struct ivtv_mailbox_data *mbdata = (cmd >= 128) ? &itv->enc_mbox : &itv->dec_mbox;
203 volatile struct ivtv_mailbox __iomem *mbox;
204 int api_timeout = msecs_to_jiffies(1000);
205 int flags, mb, i;
206 unsigned long then;
207
208
209 if (NULL == mbdata) {
210 IVTV_ERR("No mailbox allocated\n");
211 return -ENODEV;
212 }
213 if (args < 0 || args > CX2341X_MBOX_MAX_DATA ||
214 cmd < 0 || cmd > 255 || api_info[cmd].name == NULL) {
215 IVTV_ERR("Invalid MB call: cmd = 0x%02x, args = %d\n", cmd, args);
216 return -EINVAL;
217 }
218
219 if (api_info[cmd].flags & API_HIGH_VOL) {
220 IVTV_DEBUG_HI_MB("MB Call: %s\n", api_info[cmd].name);
221 }
222 else {
223 IVTV_DEBUG_MB("MB Call: %s\n", api_info[cmd].name);
224 }
225
226
227 for (i = args; i < CX2341X_MBOX_MAX_DATA; i++)
228 data[i] = 0;
229
230
231
232
233 if (itv->api_cache[cmd].last_jiffies &&
234 time_before(jiffies,
235 itv->api_cache[cmd].last_jiffies +
236 msecs_to_jiffies(1800000)) &&
237 !memcmp(data, itv->api_cache[cmd].data, sizeof(itv->api_cache[cmd].data))) {
238 itv->api_cache[cmd].last_jiffies = jiffies;
239 return 0;
240 }
241
242 flags = api_info[cmd].flags;
243
244 if (flags & API_DMA) {
245 for (i = 0; i < 100; i++) {
246 mb = i % (mbdata->max_mbox + 1);
247 if (try_mailbox(itv, mbdata, mb)) {
248 write_mailbox(&mbdata->mbox[mb], cmd, args, data);
249 clear_bit(mb, &mbdata->busy);
250 return 0;
251 }
252 IVTV_DEBUG_WARN("%s: mailbox %d not free %08x\n",
253 api_info[cmd].name, mb, readl(&mbdata->mbox[mb].flags));
254 }
255 IVTV_WARN("Could not find free DMA mailbox for %s\n", api_info[cmd].name);
256 clear_all_mailboxes(itv, mbdata);
257 return -EBUSY;
258 }
259
260 if ((flags & API_FAST_RESULT) == API_FAST_RESULT)
261 api_timeout = msecs_to_jiffies(100);
262
263 mb = get_mailbox(itv, mbdata, flags);
264 if (mb < 0) {
265 IVTV_DEBUG_WARN("No free mailbox found (%s)\n", api_info[cmd].name);
266 clear_all_mailboxes(itv, mbdata);
267 return -EBUSY;
268 }
269 mbox = &mbdata->mbox[mb];
270 write_mailbox(mbox, cmd, args, data);
271 if (flags & API_CACHE) {
272 memcpy(itv->api_cache[cmd].data, data, sizeof(itv->api_cache[cmd].data));
273 itv->api_cache[cmd].last_jiffies = jiffies;
274 }
275 if ((flags & API_RESULT) == 0) {
276 clear_bit(mb, &mbdata->busy);
277 return 0;
278 }
279
280
281 then = jiffies;
282
283 if (!(flags & API_NO_POLL)) {
284
285 for (i = 0; i < 100; i++) {
286 if (readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)
287 break;
288 }
289 }
290 while (!(readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)) {
291 if (time_after(jiffies, then + api_timeout)) {
292 IVTV_DEBUG_WARN("Could not get result (%s)\n", api_info[cmd].name);
293
294 write_sync(0, &mbox->flags);
295 clear_bit(mb, &mbdata->busy);
296 return -EIO;
297 }
298 if (flags & API_NO_WAIT_RES)
299 mdelay(1);
300 else
301 ivtv_msleep_timeout(1, 0);
302 }
303 if (time_after(jiffies, then + msecs_to_jiffies(100)))
304 IVTV_DEBUG_WARN("%s took %u jiffies\n",
305 api_info[cmd].name,
306 jiffies_to_msecs(jiffies - then));
307
308 for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
309 data[i] = readl(&mbox->data[i]);
310 write_sync(0, &mbox->flags);
311 clear_bit(mb, &mbdata->busy);
312 return 0;
313}
314
315int ivtv_api(struct ivtv *itv, int cmd, int args, u32 data[])
316{
317 int res = ivtv_api_call(itv, cmd, args, data);
318
319
320
321
322 return (res == -EBUSY) ? ivtv_api_call(itv, cmd, args, data) : res;
323}
324
325int ivtv_api_func(void *priv, u32 cmd, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
326{
327 return ivtv_api(priv, cmd, in, data);
328}
329
330int ivtv_vapi_result(struct ivtv *itv, u32 data[CX2341X_MBOX_MAX_DATA], int cmd, int args, ...)
331{
332 va_list ap;
333 int i;
334
335 va_start(ap, args);
336 for (i = 0; i < args; i++) {
337 data[i] = va_arg(ap, u32);
338 }
339 va_end(ap);
340 return ivtv_api(itv, cmd, args, data);
341}
342
343int ivtv_vapi(struct ivtv *itv, int cmd, int args, ...)
344{
345 u32 data[CX2341X_MBOX_MAX_DATA];
346 va_list ap;
347 int i;
348
349 va_start(ap, args);
350 for (i = 0; i < args; i++) {
351 data[i] = va_arg(ap, u32);
352 }
353 va_end(ap);
354 return ivtv_api(itv, cmd, args, data);
355}
356
357
358void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb,
359 int argc, u32 data[])
360{
361 volatile u32 __iomem *p = mbdata->mbox[mb].data;
362 int i;
363 for (i = 0; i < argc; i++, p++)
364 data[i] = readl(p);
365}
366
367
368void ivtv_mailbox_cache_invalidate(struct ivtv *itv)
369{
370 int i;
371 for (i = 0; i < 256; i++)
372 itv->api_cache[i].last_jiffies = 0;
373}
374
