1 /*
2 *
3 * $Id$
4 *
5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
6 * Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License
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
23 #include <linux/device.h> // for linux/firmware.h
24 #include <linux/firmware.h>
25 #include "pvrusb2-util.h"
26 #include "pvrusb2-encoder.h"
27 #include "pvrusb2-hdw-internal.h"
28 #include "pvrusb2-debug.h"
29 #include "pvrusb2-fx2-cmd.h"
30
31
32
33 /* Firmware mailbox flags - definitions found from ivtv */
34 #define IVTV_MBOX_FIRMWARE_DONE 0x00000004
35 #define IVTV_MBOX_DRIVER_DONE 0x00000002
36 #define IVTV_MBOX_DRIVER_BUSY 0x00000001
37
38 #define MBOX_BASE 0x44
39
40
41 static int pvr2_encoder_write_words(struct pvr2_hdw *hdw,
42 unsigned int offs,
43 const u32 *data, unsigned int dlen)
44 {
45 unsigned int idx,addr;
46 unsigned int bAddr;
47 int ret;
48 unsigned int chunkCnt;
49
50 /*
51
52 Format: First byte must be 0x01. Remaining 32 bit words are
53 spread out into chunks of 7 bytes each, with the first 4 bytes
54 being the data word (little endian), and the next 3 bytes
55 being the address where that data word is to be written (big
56 endian). Repeat request for additional words, with offset
57 adjusted accordingly.
58
59 */
60 while (dlen) {
61 chunkCnt = 8;
62 if (chunkCnt > dlen) chunkCnt = dlen;
63 memset(hdw->cmd_buffer,0,sizeof(hdw->cmd_buffer));
64 bAddr = 0;
65 hdw->cmd_buffer[bAddr++] = FX2CMD_MEM_WRITE_DWORD;
66 for (idx = 0; idx < chunkCnt; idx++) {
67 addr = idx + offs;
68 hdw->cmd_buffer[bAddr+6] = (addr & 0xffu);
69 hdw->cmd_buffer[bAddr+5] = ((addr>>8) & 0xffu);
70 hdw->cmd_buffer[bAddr+4] = ((addr>>16) & 0xffu);
71 PVR2_DECOMPOSE_LE(hdw->cmd_buffer, bAddr,data[idx]);
72 bAddr += 7;
73 }
74 ret = pvr2_send_request(hdw,
75 hdw->cmd_buffer,1+(chunkCnt*7),
76 NULL,0);
77 if (ret) return ret;
78 data += chunkCnt;
79 dlen -= chunkCnt;
80 offs += chunkCnt;
81 }
82
83 return 0;
84 }
85
86
87 static int pvr2_encoder_read_words(struct pvr2_hdw *hdw,
88 unsigned int offs,
89 u32 *data, unsigned int dlen)
90 {
91 unsigned int idx;
92 int ret;
93 unsigned int chunkCnt;
94
95 /*
96
97 Format: First byte must be 0x02 (status check) or 0x28 (read
98 back block of 32 bit words). Next 6 bytes must be zero,
99 followed by a single byte of MBOX_BASE+offset for portion to
100 be read. Returned data is packed set of 32 bits words that
101 were read.
102
103 */
104
105 while (dlen) {
106 chunkCnt = 16;
107 if (chunkCnt > dlen) chunkCnt = dlen;
108 if (chunkCnt < 16) chunkCnt = 1;
109 hdw->cmd_buffer[0] =
110 ((chunkCnt == 1) ?
111 FX2CMD_MEM_READ_DWORD : FX2CMD_MEM_READ_64BYTES);
112 hdw->cmd_buffer[1] = 0;
113 hdw->cmd_buffer[2] = 0;
114 hdw->cmd_buffer[3] = 0;
115 hdw->cmd_buffer[4] = 0;
116 hdw->cmd_buffer[5] = ((offs>>16) & 0xffu);
117 hdw->cmd_buffer[6] = ((offs>>8) & 0xffu);
118 hdw->cmd_buffer[7] = (offs & 0xffu);
119 ret = pvr2_send_request(hdw,
120 hdw->cmd_buffer,8,
121 hdw->cmd_buffer,
122 (chunkCnt == 1 ? 4 : 16 * 4));
123 if (ret) return ret;
124
125 for (idx = 0; idx < chunkCnt; idx++) {
126 data[idx] = PVR2_COMPOSE_LE(hdw->cmd_buffer,idx*4);
127 }
128 data += chunkCnt;
129 dlen -= chunkCnt;
130 offs += chunkCnt;
131 }
132
133 return 0;
134 }
135
136
137 /* This prototype is set up to be compatible with the
138 cx2341x_mbox_func prototype in cx2341x.h, which should be in
139 kernels 2.6.18 or later. We do this so that we can enable
140 cx2341x.ko to write to our encoder (by handing it a pointer to this
141 function). For earlier kernels this doesn't really matter. */
142 static int pvr2_encoder_cmd(void *ctxt,
143 u32 cmd,
144 int arg_cnt_send,
145 int arg_cnt_recv,
146 u32 *argp)
147 {
148 unsigned int poll_count;
149 unsigned int try_count = 0;
150 int retry_flag;
151 int ret = 0;
152 unsigned int idx;
153 /* These sizes look to be limited by the FX2 firmware implementation */
154 u32 wrData[16];
155 u32 rdData[16];
156 struct pvr2_hdw *hdw = (struct pvr2_hdw *)ctxt;
157
158
159 /*
160
161 The encoder seems to speak entirely using blocks 32 bit words.
162 In ivtv driver terms, this is a mailbox at MBOX_BASE which we
163 populate with data and watch what the hardware does with it.
164 The first word is a set of flags used to control the
165 transaction, the second word is the command to execute, the
166 third byte is zero (ivtv driver suggests that this is some
167 kind of return value), and the fourth byte is a specified
168 timeout (windows driver always uses 0x00060000 except for one
169 case when it is zero). All successive words are the argument
170 words for the command.
171
172 First, write out the entire set of words, with the first word
173 being zero.
174
175 Next, write out just the first word again, but set it to
176 IVTV_MBOX_DRIVER_DONE | IVTV_DRIVER_BUSY this time (which
177 probably means "go").
178
179 Next, read back the return count words. Check the first word,
180 which should have IVTV_MBOX_FIRMWARE_DONE set. If however
181 that bit is not set, then the command isn't done so repeat the
182 read until it is set.
183
184 Finally, write out just the first word again, but set it to
185 0x0 this time (which probably means "idle").
186
187 */
188
189 if (arg_cnt_send > (ARRAY_SIZE(wrData) - 4)) {
190 pvr2_trace(
191 PVR2_TRACE_ERROR_LEGS,
192 "Failed to write cx23416 command"
193 " - too many input arguments"
194 " (was given %u limit %lu)",
195 arg_cnt_send, (long unsigned) ARRAY_SIZE(wrData) - 4);
196 return -EINVAL;
197 }
198
199 if (arg_cnt_recv > (ARRAY_SIZE(rdData) - 4)) {
200 pvr2_trace(
201 PVR2_TRACE_ERROR_LEGS,
202 "Failed to write cx23416 command"
203 " - too many return arguments"
204 " (was given %u limit %lu)",
205 arg_cnt_recv, (long unsigned) ARRAY_SIZE(rdData) - 4);
206 return -EINVAL;
207 }
208
209
210 LOCK_TAKE(hdw->ctl_lock); do {
211
212 if (!hdw->state_encoder_ok) {
213 ret = -EIO;
214 break;
215 }
216
217 retry_flag = 0;
218 try_count++;
219 ret = 0;
220 wrData[0] = 0;
221 wrData[1] = cmd;
222 wrData[2] = 0;
223 wrData[3] = 0x00060000;
224 for (idx = 0; idx < arg_cnt_send; idx++) {
225 wrData[idx+4] = argp[idx];
226 }
227 for (; idx < ARRAY_SIZE(wrData) - 4; idx++) {
228 wrData[idx+4] = 0;
229 }
230
231 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,idx);
232 if (ret) break;
233 wrData[0] = IVTV_MBOX_DRIVER_DONE|IVTV_MBOX_DRIVER_BUSY;
234 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
235 if (ret) break;
236 poll_count = 0;
237 while (1) {
238 poll_count++;
239 ret = pvr2_encoder_read_words(hdw,MBOX_BASE,rdData,
240 arg_cnt_recv+4);
241 if (ret) {
242 break;
243 }
244 if (rdData[0] & IVTV_MBOX_FIRMWARE_DONE) {
245 break;
246 }
247 if (rdData[0] && (poll_count < 1000)) continue;
248 if (!rdData[0]) {
249 retry_flag = !0;
250 pvr2_trace(
251 PVR2_TRACE_ERROR_LEGS,
252 "Encoder timed out waiting for us"
253 "; arranging to retry");
254 } else {
255 pvr2_trace(
256 PVR2_TRACE_ERROR_LEGS,
257 "***WARNING*** device's encoder"
258 " appears to be stuck"
259 " (status=0x%08x)",rdData[0]);
260 }
261 pvr2_trace(
262 PVR2_TRACE_ERROR_LEGS,
263 "Encoder command: 0x%02x",cmd);
264 for (idx = 4; idx < arg_cnt_send; idx++) {
265 pvr2_trace(
266 PVR2_TRACE_ERROR_LEGS,
267 "Encoder arg%d: 0x%08x",
268 idx-3,wrData[idx]);
269 }
270 ret = -EBUSY;
271 break;
272 }
273 if (retry_flag) {
274 if (try_count < 20) continue;
275 pvr2_trace(
276 PVR2_TRACE_ERROR_LEGS,
277 "Too many retries...");
278 ret = -EBUSY;
279 }
280 if (ret) {
281 hdw->state_encoder_ok = 0;
282 pvr2_trace(PVR2_TRACE_STBITS,
283 "State bit %s <-- %s",
284 "state_encoder_ok",
285 (hdw->state_encoder_ok ? "true" : "false"));
286 pvr2_trace(
287 PVR2_TRACE_ERROR_LEGS,
288 "Giving up on command."
289 " This is normally recovered by the driver.");
290 break;
291 }
292 wrData[0] = 0x7;
293 for (idx = 0; idx < arg_cnt_recv; idx++) {
294 argp[idx] = rdData[idx+4];
295 }
296
297 wrData[0] = 0x0;
298 ret = pvr2_encoder_write_words(hdw,MBOX_BASE,wrData,1);
299 if (ret) break;
300
301 } while(0); LOCK_GIVE(hdw->ctl_lock);
302
303 return ret;
304 }
305
306
307 static int pvr2_encoder_vcmd(struct pvr2_hdw *hdw, int cmd,
308 int args, ...)
309 {
310 va_list vl;
311 unsigned int idx;
312 u32 data[12];
313
314 if (args > ARRAY_SIZE(data)) {
315 pvr2_trace(
316 PVR2_TRACE_ERROR_LEGS,
317 "Failed to write cx23416 command"
318 " - too many arguments"
319 " (was given %u limit %lu)",
320 args, (long unsigned) ARRAY_SIZE(data));
321 return -EINVAL;
322 }
323
324 va_start(vl, args);
325 for (idx = 0; idx < args; idx++) {
326 data[idx] = va_arg(vl, u32);
327 }
328 va_end(vl);
329
330 return pvr2_encoder_cmd(hdw,cmd,args,0,data);
331 }
332
333
334 /* This implements some extra setup for the encoder that seems to be
335 specific to the PVR USB2 hardware. */
336 static int pvr2_encoder_prep_config(struct pvr2_hdw *hdw)
337 {
338 int ret = 0;
339 int encMisc3Arg = 0;
340
341 #if 0
342 /* This inexplicable bit happens in the Hauppage windows
343 driver (for both 24xxx and 29xxx devices). However I
344 currently see no difference in behavior with or without
345 this stuff. Leave this here as a note of its existence,
346 but don't use it. */
347 LOCK_TAKE(hdw->ctl_lock); do {
348 u32 dat[1];
349 dat[0] = 0x80000640;
350 pvr2_encoder_write_words(hdw,0x01fe,dat,1);
351 pvr2_encoder_write_words(hdw,0x023e,dat,1);
352 } while(0); LOCK_GIVE(hdw->ctl_lock);
353 #endif
354
355 /* Mike Isely <isely@pobox.com> 26-Jan-2006 The windows driver
356 sends the following list of ENC_MISC commands (for both
357 24xxx and 29xxx devices). Meanings are not entirely clear,
358 however without the ENC_MISC(3,1) command then we risk
359 random perpetual video corruption whenever the video input
360 breaks up for a moment (like when switching channels). */
361
362
363 #if 0
364 /* This ENC_MISC(5,0) command seems to hurt 29xxx sync
365 performance on channel changes, but is not a problem on
366 24xxx devices. */
367 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 5,0,0,0);
368 #endif
369
370 /* This ENC_MISC(3,encMisc3Arg) command is critical - without
371 it there will eventually be video corruption. Also, the
372 saa7115 case is strange - the Windows driver is passing 1
373 regardless of device type but if we have 1 for saa7115
374 devices the video turns sluggish. */
375 if (hdw->hdw_desc->flag_has_cx25840) {
376 encMisc3Arg = 1;
377 } else {
378 encMisc3Arg = 0;
379 }
380 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 3,
381 encMisc3Arg,0,0);
382
383 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 8,0,0,0);
384
385 #if 0
386 /* This ENC_MISC(4,1) command is poisonous, so it is commented
387 out. But I'm leaving it here anyway to document its
388 existence in the Windows driver. The effect of this
389 command is that apps displaying the stream become sluggish
390 with stuttering video. */
391 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 4,1,0,0);
392 #endif
393
394 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4, 0,3,0,0);
395 ret |= pvr2_encoder_vcmd(hdw, CX2341X_ENC_MISC,4,15,0,0,0);
396
397 return ret;
398 }
399
400 int pvr2_encoder_adjust(struct pvr2_hdw *hdw)
401 {
402 int ret;
403 ret = cx2341x_update(hdw,pvr2_encoder_cmd,
404 (hdw->enc_cur_valid ? &hdw->enc_cur_state : NULL),
405 &hdw->enc_ctl_state);
406 if (ret) {
407 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
408 "Error from cx2341x module code=%d",ret);
409 } else {
410 memcpy(&hdw->enc_cur_state,&hdw->enc_ctl_state,
411 sizeof(struct cx2341x_mpeg_params));
412 hdw->enc_cur_valid = !0;
413 }
414 return ret;
415 }
416
417
418 int pvr2_encoder_configure(struct pvr2_hdw *hdw)
419 {
420 int ret;
421 int val;
422 pvr2_trace(PVR2_TRACE_ENCODER,"pvr2_encoder_configure"
423 " (cx2341x module)");
424 hdw->enc_ctl_state.port = CX2341X_PORT_STREAMING;
425 hdw->enc_ctl_state.width = hdw->res_hor_val;
426 hdw->enc_ctl_state.height = hdw->res_ver_val;
427 hdw->enc_ctl_state.is_50hz = ((hdw->std_mask_cur & V4L2_STD_525_60) ?
428 0 : 1);
429
430 ret = 0;
431
432 ret |= pvr2_encoder_prep_config(hdw);
433
434 /* saa7115: 0xf0 */
435 val = 0xf0;
436 if (hdw->hdw_desc->flag_has_cx25840) {
437 /* ivtv cx25840: 0x140 */
438 val = 0x140;
439 }
440
441 if (!ret) ret = pvr2_encoder_vcmd(
442 hdw,CX2341X_ENC_SET_NUM_VSYNC_LINES, 2,
443 val, val);
444
445 /* setup firmware to notify us about some events (don't know why...) */
446 if (!ret) ret = pvr2_encoder_vcmd(
447 hdw,CX2341X_ENC_SET_EVENT_NOTIFICATION, 4,
448 0, 0, 0x10000000, 0xffffffff);
449
450 if (!ret) ret = pvr2_encoder_vcmd(
451 hdw,CX2341X_ENC_SET_VBI_LINE, 5,
452 0xffffffff,0,0,0,0);
453
454 if (ret) {
455 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
456 "Failed to configure cx23416");
457 return ret;
458 }
459
460 ret = pvr2_encoder_adjust(hdw);
461 if (ret) return ret;
462
463 ret = pvr2_encoder_vcmd(
464 hdw, CX2341X_ENC_INITIALIZE_INPUT, 0);
465
466 if (ret) {
467 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
468 "Failed to initialize cx23416 video input");
469 return ret;
470 }
471
472 return 0;
473 }
474
475
476 int pvr2_encoder_start(struct pvr2_hdw *hdw)
477 {
478 int status;
479
480 /* unmask some interrupts */
481 pvr2_write_register(hdw, 0x0048, 0xbfffffff);
482
483 /* change some GPIO data */
484 pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000481);
485 pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000000);
486
487 pvr2_encoder_vcmd(hdw,CX2341X_ENC_MUTE_VIDEO,1,
488 hdw->input_val == PVR2_CVAL_INPUT_RADIO ? 1 : 0);
489
490 switch (hdw->active_stream_type) {
491 case pvr2_config_vbi:
492 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
493 0x01,0x14);
494 break;
495 case pvr2_config_mpeg:
496 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
497 0,0x13);
498 break;
499 default: /* Unhandled cases for now */
500 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_START_CAPTURE,2,
501 0,0x13);
502 break;
503 }
504 return status;
505 }
506
507 int pvr2_encoder_stop(struct pvr2_hdw *hdw)
508 {
509 int status;
510
511 /* mask all interrupts */
512 pvr2_write_register(hdw, 0x0048, 0xffffffff);
513
514 switch (hdw->active_stream_type) {
515 case pvr2_config_vbi:
516 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
517 0x01,0x01,0x14);
518 break;
519 case pvr2_config_mpeg:
520 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
521 0x01,0,0x13);
522 break;
523 default: /* Unhandled cases for now */
524 status = pvr2_encoder_vcmd(hdw,CX2341X_ENC_STOP_CAPTURE,3,
525 0x01,0,0x13);
526 break;
527 }
528
529 /* change some GPIO data */
530 /* Note: Bit d7 of dir appears to control the LED. So we shut it
531 off here. */
532 pvr2_hdw_gpio_chg_dir(hdw,0xffffffff,0x00000401);
533 pvr2_hdw_gpio_chg_out(hdw,0xffffffff,0x00000000);
534
535 return status;
536 }
537
538
539 /*
540 Stuff for Emacs to see, in order to encourage consistent editing style:
541 *** Local Variables: ***
542 *** mode: c ***
543 *** fill-column: 70 ***
544 *** tab-width: 8 ***
545 *** c-basic-offset: 8 ***
546 *** End: ***
547 */
548
|
This page was automatically generated by the
LXR engine.
|