?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (4676): Dynamic cx88 mpeg port management for HVR1300 MPEG2/DVB-T support.
[linux-2.6/mini2440.git] / drivers / media / video / cx88 / cx88-blackbird.c
blob0037188d77d469a1abdc3ea61b3f41718d250fb6
1 /*
2 *
3 * Support for a cx23416 mpeg encoder via cx2388x host port.
4 * "blackbird" reference design.
5 *
6 * (c) 2004 Jelle Foks <jelle@foks.8m.com>
7 * (c) 2004 Gerd Knorr <kraxel@bytesex.org>
8 *
9 * Includes parts from the ivtv driver( http://ivtv.sourceforge.net/),
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/init.h>
29 #include <linux/fs.h>
30 #include <linux/delay.h>
31 #include <linux/device.h>
32 #include <linux/firmware.h>
33 #include <media/v4l2-common.h>
34 #include <media/cx2341x.h>
35
36 #include "cx88.h"
37
38 MODULE_DESCRIPTION("driver for cx2388x/cx23416 based mpeg encoder cards");
39 MODULE_AUTHOR("Jelle Foks <jelle@foks.8m.com>, Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
40 MODULE_LICENSE("GPL");
41
42 static unsigned int mpegbufs = 32;
43 module_param(mpegbufs,int,0644);
44 MODULE_PARM_DESC(mpegbufs,"number of mpeg buffers, range 2-32");
45
46 static unsigned int debug = 0;
47 module_param(debug,int,0644);
48 MODULE_PARM_DESC(debug,"enable debug messages [blackbird]");
49
50 #define dprintk(level,fmt, arg...) if (debug >= level) \
51 printk(KERN_DEBUG "%s/2-bb: " fmt, dev->core->name , ## arg)
52
53
54 /* ------------------------------------------------------------------ */
55
56 #define BLACKBIRD_FIRM_IMAGE_SIZE 256*1024
57
58 /* defines below are from ivtv-driver.h */
59
60 #define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF
61
62 /* Firmware API commands */
63 #define IVTV_API_STD_TIMEOUT 500
64
65 enum blackbird_capture_type {
66 BLACKBIRD_MPEG_CAPTURE,
67 BLACKBIRD_RAW_CAPTURE,
68 BLACKBIRD_RAW_PASSTHRU_CAPTURE
69 };
70 enum blackbird_capture_bits {
71 BLACKBIRD_RAW_BITS_NONE = 0x00,
72 BLACKBIRD_RAW_BITS_YUV_CAPTURE = 0x01,
73 BLACKBIRD_RAW_BITS_PCM_CAPTURE = 0x02,
74 BLACKBIRD_RAW_BITS_VBI_CAPTURE = 0x04,
75 BLACKBIRD_RAW_BITS_PASSTHRU_CAPTURE = 0x08,
76 BLACKBIRD_RAW_BITS_TO_HOST_CAPTURE = 0x10
77 };
78 enum blackbird_capture_end {
79 BLACKBIRD_END_AT_GOP, /* stop at the end of gop, generate irq */
80 BLACKBIRD_END_NOW, /* stop immediately, no irq */
81 };
82 enum blackbird_framerate {
83 BLACKBIRD_FRAMERATE_NTSC_30, /* NTSC: 30fps */
84 BLACKBIRD_FRAMERATE_PAL_25 /* PAL: 25fps */
85 };
86 enum blackbird_stream_port {
87 BLACKBIRD_OUTPUT_PORT_MEMORY,
88 BLACKBIRD_OUTPUT_PORT_STREAMING,
89 BLACKBIRD_OUTPUT_PORT_SERIAL
90 };
91 enum blackbird_data_xfer_status {
92 BLACKBIRD_MORE_BUFFERS_FOLLOW,
93 BLACKBIRD_LAST_BUFFER,
94 };
95 enum blackbird_picture_mask {
96 BLACKBIRD_PICTURE_MASK_NONE,
97 BLACKBIRD_PICTURE_MASK_I_FRAMES,
98 BLACKBIRD_PICTURE_MASK_I_P_FRAMES = 0x3,
99 BLACKBIRD_PICTURE_MASK_ALL_FRAMES = 0x7,
100 };
101 enum blackbird_vbi_mode_bits {
102 BLACKBIRD_VBI_BITS_SLICED,
103 BLACKBIRD_VBI_BITS_RAW,
104 };
105 enum blackbird_vbi_insertion_bits {
106 BLACKBIRD_VBI_BITS_INSERT_IN_XTENSION_USR_DATA,
107 BLACKBIRD_VBI_BITS_INSERT_IN_PRIVATE_PACKETS = 0x1 << 1,
108 BLACKBIRD_VBI_BITS_SEPARATE_STREAM = 0x2 << 1,
109 BLACKBIRD_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1,
110 BLACKBIRD_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1,
111 };
112 enum blackbird_dma_unit {
113 BLACKBIRD_DMA_BYTES,
114 BLACKBIRD_DMA_FRAMES,
115 };
116 enum blackbird_dma_transfer_status_bits {
117 BLACKBIRD_DMA_TRANSFER_BITS_DONE = 0x01,
118 BLACKBIRD_DMA_TRANSFER_BITS_ERROR = 0x04,
119 BLACKBIRD_DMA_TRANSFER_BITS_LL_ERROR = 0x10,
120 };
121 enum blackbird_pause {
122 BLACKBIRD_PAUSE_ENCODING,
123 BLACKBIRD_RESUME_ENCODING,
124 };
125 enum blackbird_copyright {
126 BLACKBIRD_COPYRIGHT_OFF,
127 BLACKBIRD_COPYRIGHT_ON,
128 };
129 enum blackbird_notification_type {
130 BLACKBIRD_NOTIFICATION_REFRESH,
131 };
132 enum blackbird_notification_status {
133 BLACKBIRD_NOTIFICATION_OFF,
134 BLACKBIRD_NOTIFICATION_ON,
135 };
136 enum blackbird_notification_mailbox {
137 BLACKBIRD_NOTIFICATION_NO_MAILBOX = -1,
138 };
139 enum blackbird_field1_lines {
140 BLACKBIRD_FIELD1_SAA7114 = 0x00EF, /* 239 */
141 BLACKBIRD_FIELD1_SAA7115 = 0x00F0, /* 240 */
142 BLACKBIRD_FIELD1_MICRONAS = 0x0105, /* 261 */
143 };
144 enum blackbird_field2_lines {
145 BLACKBIRD_FIELD2_SAA7114 = 0x00EF, /* 239 */
146 BLACKBIRD_FIELD2_SAA7115 = 0x00F0, /* 240 */
147 BLACKBIRD_FIELD2_MICRONAS = 0x0106, /* 262 */
148 };
149 enum blackbird_custom_data_type {
150 BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
151 BLACKBIRD_CUSTOM_PRIVATE_PACKET,
152 };
153 enum blackbird_mute {
154 BLACKBIRD_UNMUTE,
155 BLACKBIRD_MUTE,
156 };
157 enum blackbird_mute_video_mask {
158 BLACKBIRD_MUTE_VIDEO_V_MASK = 0x0000FF00,
159 BLACKBIRD_MUTE_VIDEO_U_MASK = 0x00FF0000,
160 BLACKBIRD_MUTE_VIDEO_Y_MASK = 0xFF000000,
161 };
162 enum blackbird_mute_video_shift {
163 BLACKBIRD_MUTE_VIDEO_V_SHIFT = 8,
164 BLACKBIRD_MUTE_VIDEO_U_SHIFT = 16,
165 BLACKBIRD_MUTE_VIDEO_Y_SHIFT = 24,
166 };
167
168 /* Registers */
169 #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8 /*| IVTV_REG_OFFSET*/)
170 #define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC /*| IVTV_REG_OFFSET*/)
171 #define IVTV_REG_SPU (0x9050 /*| IVTV_REG_OFFSET*/)
172 #define IVTV_REG_HW_BLOCKS (0x9054 /*| IVTV_REG_OFFSET*/)
173 #define IVTV_REG_VPU (0x9058 /*| IVTV_REG_OFFSET*/)
174 #define IVTV_REG_APU (0xA064 /*| IVTV_REG_OFFSET*/)
175
176 /* ------------------------------------------------------------------ */
177
178 static void host_setup(struct cx88_core *core)
179 {
180 /* toggle reset of the host */
181 cx_write(MO_GPHST_SOFT_RST, 1);
182 udelay(100);
183 cx_write(MO_GPHST_SOFT_RST, 0);
184 udelay(100);
185
186 /* host port setup */
187 cx_write(MO_GPHST_WSC, 0x44444444U);
188 cx_write(MO_GPHST_XFR, 0);
189 cx_write(MO_GPHST_WDTH, 15);
190 cx_write(MO_GPHST_HDSHK, 0);
191 cx_write(MO_GPHST_MUX16, 0x44448888U);
192 cx_write(MO_GPHST_MODE, 0);
193 }
194
195 /* ------------------------------------------------------------------ */
196
197 #define P1_MDATA0 0x390000
198 #define P1_MDATA1 0x390001
199 #define P1_MDATA2 0x390002
200 #define P1_MDATA3 0x390003
201 #define P1_MADDR2 0x390004
202 #define P1_MADDR1 0x390005
203 #define P1_MADDR0 0x390006
204 #define P1_RDATA0 0x390008
205 #define P1_RDATA1 0x390009
206 #define P1_RDATA2 0x39000A
207 #define P1_RDATA3 0x39000B
208 #define P1_RADDR0 0x39000C
209 #define P1_RADDR1 0x39000D
210 #define P1_RRDWR 0x39000E
211
212 static int wait_ready_gpio0_bit1(struct cx88_core *core, u32 state)
213 {
214 unsigned long timeout = jiffies + msecs_to_jiffies(1);
215 u32 gpio0,need;
216
217 need = state ? 2 : 0;
218 for (;;) {
219 gpio0 = cx_read(MO_GP0_IO) & 2;
220 if (need == gpio0)
221 return 0;
222 if (time_after(jiffies,timeout))
223 return -1;
224 udelay(1);
225 }
226 }
227
228 static int memory_write(struct cx88_core *core, u32 address, u32 value)
229 {
230 /* Warning: address is dword address (4 bytes) */
231 cx_writeb(P1_MDATA0, (unsigned int)value);
232 cx_writeb(P1_MDATA1, (unsigned int)(value >> 8));
233 cx_writeb(P1_MDATA2, (unsigned int)(value >> 16));
234 cx_writeb(P1_MDATA3, (unsigned int)(value >> 24));
235 cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) | 0x40);
236 cx_writeb(P1_MADDR1, (unsigned int)(address >> 8));
237 cx_writeb(P1_MADDR0, (unsigned int)address);
238 cx_read(P1_MDATA0);
239 cx_read(P1_MADDR0);
240
241 return wait_ready_gpio0_bit1(core,1);
242 }
243
244 static int memory_read(struct cx88_core *core, u32 address, u32 *value)
245 {
246 int retval;
247 u32 val;
248
249 /* Warning: address is dword address (4 bytes) */
250 cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) & ~0xC0);
251 cx_writeb(P1_MADDR1, (unsigned int)(address >> 8));
252 cx_writeb(P1_MADDR0, (unsigned int)address);
253 cx_read(P1_MADDR0);
254
255 retval = wait_ready_gpio0_bit1(core,1);
256
257 cx_writeb(P1_MDATA3, 0);
258 val = (unsigned char)cx_read(P1_MDATA3) << 24;
259 cx_writeb(P1_MDATA2, 0);
260 val |= (unsigned char)cx_read(P1_MDATA2) << 16;
261 cx_writeb(P1_MDATA1, 0);
262 val |= (unsigned char)cx_read(P1_MDATA1) << 8;
263 cx_writeb(P1_MDATA0, 0);
264 val |= (unsigned char)cx_read(P1_MDATA0);
265
266 *value = val;
267 return retval;
268 }
269
270 static int register_write(struct cx88_core *core, u32 address, u32 value)
271 {
272 cx_writeb(P1_RDATA0, (unsigned int)value);
273 cx_writeb(P1_RDATA1, (unsigned int)(value >> 8));
274 cx_writeb(P1_RDATA2, (unsigned int)(value >> 16));
275 cx_writeb(P1_RDATA3, (unsigned int)(value >> 24));
276 cx_writeb(P1_RADDR0, (unsigned int)address);
277 cx_writeb(P1_RADDR1, (unsigned int)(address >> 8));
278 cx_writeb(P1_RRDWR, 1);
279 cx_read(P1_RDATA0);
280 cx_read(P1_RADDR0);
281
282 return wait_ready_gpio0_bit1(core,1);
283 }
284
285
286 static int register_read(struct cx88_core *core, u32 address, u32 *value)
287 {
288 int retval;
289 u32 val;
290
291 cx_writeb(P1_RADDR0, (unsigned int)address);
292 cx_writeb(P1_RADDR1, (unsigned int)(address >> 8));
293 cx_writeb(P1_RRDWR, 0);
294 cx_read(P1_RADDR0);
295
296 retval = wait_ready_gpio0_bit1(core,1);
297 val = (unsigned char)cx_read(P1_RDATA0);
298 val |= (unsigned char)cx_read(P1_RDATA1) << 8;
299 val |= (unsigned char)cx_read(P1_RDATA2) << 16;
300 val |= (unsigned char)cx_read(P1_RDATA3) << 24;
301
302 *value = val;
303 return retval;
304 }
305
306 /* ------------------------------------------------------------------ */
307
308 static int blackbird_mbox_func(void *priv, int command, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
309 {
310 struct cx8802_dev *dev = priv;
311 unsigned long timeout;
312 u32 value, flag, retval;
313 int i;
314
315 dprintk(1,"%s: 0x%X\n", __FUNCTION__, command);
316
317 /* this may not be 100% safe if we can't read any memory location
318 without side effects */
319 memory_read(dev->core, dev->mailbox - 4, &value);
320 if (value != 0x12345678) {
321 dprintk(0, "Firmware and/or mailbox pointer not initialized or corrupted\n");
322 return -1;
323 }
324
325 memory_read(dev->core, dev->mailbox, &flag);
326 if (flag) {
327 dprintk(0, "ERROR: Mailbox appears to be in use (%x)\n", flag);
328 return -1;
329 }
330
331 flag |= 1; /* tell 'em we're working on it */
332 memory_write(dev->core, dev->mailbox, flag);
333
334 /* write command + args + fill remaining with zeros */
335 memory_write(dev->core, dev->mailbox + 1, command); /* command code */
336 memory_write(dev->core, dev->mailbox + 3, IVTV_API_STD_TIMEOUT); /* timeout */
337 for (i = 0; i < in; i++) {
338 memory_write(dev->core, dev->mailbox + 4 + i, data[i]);
339 dprintk(1, "API Input %d = %d\n", i, data[i]);
340 }
341 for (; i < CX2341X_MBOX_MAX_DATA; i++)
342 memory_write(dev->core, dev->mailbox + 4 + i, 0);
343
344 flag |= 3; /* tell 'em we're done writing */
345 memory_write(dev->core, dev->mailbox, flag);
346
347 /* wait for firmware to handle the API command */
348 timeout = jiffies + msecs_to_jiffies(10);
349 for (;;) {
350 memory_read(dev->core, dev->mailbox, &flag);
351 if (0 != (flag & 4))
352 break;
353 if (time_after(jiffies,timeout)) {
354 dprintk(0, "ERROR: API Mailbox timeout\n");
355 return -1;
356 }
357 udelay(10);
358 }
359
360 /* read output values */
361 for (i = 0; i < out; i++) {
362 memory_read(dev->core, dev->mailbox + 4 + i, data + i);
363 dprintk(1, "API Output %d = %d\n", i, data[i]);
364 }
365
366 memory_read(dev->core, dev->mailbox + 2, &retval);
367 dprintk(1, "API result = %d\n",retval);
368
369 flag = 0;
370 memory_write(dev->core, dev->mailbox, flag);
371 return retval;
372 }
373 /* ------------------------------------------------------------------ */
374
375 /* We don't need to call the API often, so using just one mailbox will probably suffice */
376 static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
377 u32 inputcnt, u32 outputcnt, ...)
378 {
379 u32 data[CX2341X_MBOX_MAX_DATA];
380 va_list vargs;
381 int i, err;
382
383 va_start(vargs, outputcnt);
384
385 for (i = 0; i < inputcnt; i++) {
386 data[i] = va_arg(vargs, int);
387 }
388 err = blackbird_mbox_func(dev, command, inputcnt, outputcnt, data);
389 for (i = 0; i < outputcnt; i++) {
390 int *vptr = va_arg(vargs, int *);
391 *vptr = data[i];
392 }
393 va_end(vargs);
394 return err;
395 }
396
397 static int blackbird_find_mailbox(struct cx8802_dev *dev)
398 {
399 u32 signature[4]={0x12345678, 0x34567812, 0x56781234, 0x78123456};
400 int signaturecnt=0;
401 u32 value;
402 int i;
403
404 for (i = 0; i < BLACKBIRD_FIRM_IMAGE_SIZE; i++) {
405 memory_read(dev->core, i, &value);
406 if (value == signature[signaturecnt])
407 signaturecnt++;
408 else
409 signaturecnt = 0;
410 if (4 == signaturecnt) {
411 dprintk(1, "Mailbox signature found\n");
412 return i+1;
413 }
414 }
415 dprintk(0, "Mailbox signature values not found!\n");
416 return -1;
417 }
418
419 static int blackbird_load_firmware(struct cx8802_dev *dev)
420 {
421 static const unsigned char magic[8] = {
422 0xa7, 0x0d, 0x00, 0x00, 0x66, 0xbb, 0x55, 0xaa
423 };
424 const struct firmware *firmware;
425 int i, retval = 0;
426 u32 value = 0;
427 u32 checksum = 0;
428 u32 *dataptr;
429
430 retval = register_write(dev->core, IVTV_REG_VPU, 0xFFFFFFED);
431 retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
432 retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_REFRESH, 0x80000640);
433 retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_PRECHARGE, 0x1A);
434 msleep(1);
435 retval |= register_write(dev->core, IVTV_REG_APU, 0);
436
437 if (retval < 0)
438 dprintk(0, "Error with register_write\n");
439
440 retval = request_firmware(&firmware, CX2341X_FIRM_ENC_FILENAME,
441 &dev->pci->dev);
442
443
444 if (retval != 0) {
445 dprintk(0, "ERROR: Hotplug firmware request failed (%s).\n",
446 CX2341X_FIRM_ENC_FILENAME);
447 dprintk(0, "Please fix your hotplug setup, the board will "
448 "not work without firmware loaded!\n");
449 return -1;
450 }
451
452 if (firmware->size != BLACKBIRD_FIRM_IMAGE_SIZE) {
453 dprintk(0, "ERROR: Firmware size mismatch (have %zd, expected %d)\n",
454 firmware->size, BLACKBIRD_FIRM_IMAGE_SIZE);
455 release_firmware(firmware);
456 return -1;
457 }
458
459 if (0 != memcmp(firmware->data, magic, 8)) {
460 dprintk(0, "ERROR: Firmware magic mismatch, wrong file?\n");
461 release_firmware(firmware);
462 return -1;
463 }
464
465 /* transfer to the chip */
466 dprintk(1,"Loading firmware ...\n");
467 dataptr = (u32*)firmware->data;
468 for (i = 0; i < (firmware->size >> 2); i++) {
469 value = *dataptr;
470 checksum += ~value;
471 memory_write(dev->core, i, value);
472 dataptr++;
473 }
474
475 /* read back to verify with the checksum */
476 for (i--; i >= 0; i--) {
477 memory_read(dev->core, i, &value);
478 checksum -= ~value;
479 }
480 if (checksum) {
481 dprintk(0, "ERROR: Firmware load failed (checksum mismatch).\n");
482 release_firmware(firmware);
483 return -1;
484 }
485 release_firmware(firmware);
486 dprintk(0, "Firmware upload successful.\n");
487
488 retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
489 retval |= register_read(dev->core, IVTV_REG_SPU, &value);
490 retval |= register_write(dev->core, IVTV_REG_SPU, value & 0xFFFFFFFE);
491 msleep(1);
492
493 retval |= register_read(dev->core, IVTV_REG_VPU, &value);
494 retval |= register_write(dev->core, IVTV_REG_VPU, value & 0xFFFFFFE8);
495
496 if (retval < 0)
497 dprintk(0, "Error with register_write\n");
498 return 0;
499 }
500
501 /**
502 Settings used by the windows tv app for PVR2000:
503 =================================================================================================================
504 Profile | Codec | Resolution | CBR/VBR | Video Qlty | V. Bitrate | Frmrate | Audio Codec | A. Bitrate | A. Mode
505 -----------------------------------------------------------------------------------------------------------------
506 MPEG-1 | MPEG1 | 352x288PAL | (CBR) | 1000:Optimal | 2000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo
507 MPEG-2 | MPEG2 | 720x576PAL | VBR | 600 :Good | 4000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo
508 VCD | MPEG1 | 352x288PAL | (CBR) | 1000:Optimal | 1150 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo
509 DVD | MPEG2 | 720x576PAL | VBR | 600 :Good | 6000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo
510 DB* DVD | MPEG2 | 720x576PAL | CBR | 600 :Good | 6000 Kbps | 25fps | MPG1 Layer2 | 224kbps | Stereo
511 =================================================================================================================
512 *DB: "DirectBurn"
513 */
514
515 static void blackbird_codec_settings(struct cx8802_dev *dev)
516 {
517 /* assign frame size */
518 blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
519 dev->height, dev->width);
520
521 dev->params.width = dev->width;
522 dev->params.height = dev->height;
523 dev->params.is_50hz = (dev->core->tvnorm->id & V4L2_STD_625_50) != 0;
524
525 cx2341x_update(dev, blackbird_mbox_func, NULL, &dev->params);
526 }
527
528 static struct v4l2_mpeg_compression default_mpeg_params = {
529 .st_type = V4L2_MPEG_PS_2,
530 .st_bitrate = {
531 .mode = V4L2_BITRATE_CBR,
532 .min = 0,
533 .target = 0,
534 .max = 0
535 },
536 .ts_pid_pmt = 16,
537 .ts_pid_audio = 260,
538 .ts_pid_video = 256,
539 .ts_pid_pcr = 259,
540 .ps_size = 0,
541 .au_type = V4L2_MPEG_AU_2_II,
542 .au_bitrate = {
543 .mode = V4L2_BITRATE_CBR,
544 .min = 224,
545 .target = 224,
546 .max = 224
547 },
548 .au_sample_rate = 48000,
549 .au_pesid = 0,
550 .vi_type = V4L2_MPEG_VI_2,
551 .vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3,
552 .vi_bitrate = {
553 .mode = V4L2_BITRATE_CBR,
554 .min = 4000,
555 .target = 4500,
556 .max = 6000
557 },
558 .vi_frame_rate = 25,
559 .vi_frames_per_gop = 12,
560 .vi_bframes_count = 2,
561 .vi_pesid = 0,
562 .closed_gops = 1,
563 .pulldown = 0
564 };
565
566 static int blackbird_initialize_codec(struct cx8802_dev *dev)
567 {
568 struct cx88_core *core = dev->core;
569 int version;
570 int retval;
571
572 dprintk(1,"Initialize codec\n");
573 retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
574 if (retval < 0) {
575 /* ping was not successful, reset and upload firmware */
576 cx_write(MO_SRST_IO, 0); /* SYS_RSTO=0 */
577 msleep(1);
578 cx_write(MO_SRST_IO, 1); /* SYS_RSTO=1 */
579 msleep(1);
580 retval = blackbird_load_firmware(dev);
581 if (retval < 0)
582 return retval;
583
584 dev->mailbox = blackbird_find_mailbox(dev);
585 if (dev->mailbox < 0)
586 return -1;
587
588 retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
589 if (retval < 0) {
590 dprintk(0, "ERROR: Firmware ping failed!\n");
591 return -1;
592 }
593
594 retval = blackbird_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1, &version);
595 if (retval < 0) {
596 dprintk(0, "ERROR: Firmware get encoder version failed!\n");
597 return -1;
598 }
599 dprintk(0, "Firmware version is 0x%08x\n", version);
600 }
601 msleep(1);
602
603 cx_write(MO_PINMUX_IO, 0x88); /* 656-8bit IO and enable MPEG parallel IO */
604 cx_clear(MO_INPUT_FORMAT, 0x100); /* chroma subcarrier lock to normal? */
605 cx_write(MO_VBOS_CONTROL, 0x84A00); /* no 656 mode, 8-bit pixels, disable VBI */
606 cx_clear(MO_OUTPUT_FORMAT, 0x0008); /* Normal Y-limits to let the mpeg encoder sync */
607
608 blackbird_codec_settings(dev);
609 msleep(1);
610
611 /* blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0xef, 0xef);
612 blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0xf0, 0xf0);
613 blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0x180, 0x180); */
614 blackbird_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0,
615 BLACKBIRD_FIELD1_SAA7115,
616 BLACKBIRD_FIELD2_SAA7115
617 );
618
619 /* blackbird_api_cmd(dev, IVTV_API_ASSIGN_PLACEHOLDER, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); */
620 blackbird_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0,
621 BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
622 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
623
624 /* initialize the video input */
625 blackbird_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0);
626
627 msleep(1);
628
629 blackbird_api_cmd(dev, CX2341X_ENC_MUTE_VIDEO, 1, 0, BLACKBIRD_UNMUTE);
630 msleep(1);
631 blackbird_api_cmd(dev, CX2341X_ENC_MUTE_AUDIO, 1, 0, BLACKBIRD_UNMUTE);
632 msleep(1);
633
634 /* start capturing to the host interface */
635 /* blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0, 0, 0x13); */
636 blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
637 BLACKBIRD_MPEG_CAPTURE,
638 BLACKBIRD_RAW_BITS_NONE
639 );
640 msleep(10);
641
642 blackbird_api_cmd(dev, CX2341X_ENC_REFRESH_INPUT, 0,0);
643 return 0;
644 }
645
646 /* ------------------------------------------------------------------ */
647
648 static int bb_buf_setup(struct videobuf_queue *q,
649 unsigned int *count, unsigned int *size)
650 {
651 struct cx8802_fh *fh = q->priv_data;
652
653 fh->dev->ts_packet_size = 188 * 4; /* was: 512 */
654 fh->dev->ts_packet_count = mpegbufs; /* was: 100 */
655
656 *size = fh->dev->ts_packet_size * fh->dev->ts_packet_count;
657 *count = fh->dev->ts_packet_count;
658 return 0;
659 }
660
661 static int
662 bb_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
663 enum v4l2_field field)
664 {
665 struct cx8802_fh *fh = q->priv_data;
666 return cx8802_buf_prepare(q, fh->dev, (struct cx88_buffer*)vb, field);
667 }
668
669 static void
670 bb_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
671 {
672 struct cx8802_fh *fh = q->priv_data;
673 cx8802_buf_queue(fh->dev, (struct cx88_buffer*)vb);
674 }
675
676 static void
677 bb_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
678 {
679 cx88_free_buffer(q, (struct cx88_buffer*)vb);
680 }
681
682 static struct videobuf_queue_ops blackbird_qops = {
683 .buf_setup = bb_buf_setup,
684 .buf_prepare = bb_buf_prepare,
685 .buf_queue = bb_buf_queue,
686 .buf_release = bb_buf_release,
687 };
688
689 /* ------------------------------------------------------------------ */
690
691 static const u32 *ctrl_classes[] = {
692 cx88_user_ctrls,
693 cx2341x_mpeg_ctrls,
694 NULL
695 };
696
697 static int blackbird_queryctrl(struct cx8802_dev *dev, struct v4l2_queryctrl *qctrl)
698 {
699 qctrl->id = v4l2_ctrl_next(ctrl_classes, qctrl->id);
700 if (qctrl->id == 0)
701 return -EINVAL;
702
703 /* Standard V4L2 controls */
704 if (cx8800_ctrl_query(qctrl) == 0)
705 return 0;
706
707 /* MPEG V4L2 controls */
708 if (cx2341x_ctrl_query(&dev->params, qctrl))
709 qctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
710 return 0;
711 }
712
713 static int blackbird_querymenu(struct cx8802_dev *dev, struct v4l2_querymenu *qmenu)
714 {
715 struct v4l2_queryctrl qctrl;
716
717 qctrl.id = qmenu->id;
718 blackbird_queryctrl(dev, &qctrl);
719 return v4l2_ctrl_query_menu(qmenu, &qctrl, cx2341x_ctrl_get_menu(qmenu->id));
720 }
721
722 /* ------------------------------------------------------------------ */
723
724 static int mpeg_do_ioctl(struct inode *inode, struct file *file,
725 unsigned int cmd, void *arg)
726 {
727 struct cx8802_fh *fh = file->private_data;
728 struct cx8802_dev *dev = fh->dev;
729 struct cx88_core *core = dev->core;
730
731 if (debug > 1)
732 v4l_print_ioctl(core->name,cmd);
733
734 switch (cmd) {
735
736 /* --- capabilities ------------------------------------------ */
737 case VIDIOC_QUERYCAP:
738 {
739 struct v4l2_capability *cap = arg;
740
741 memset(cap,0,sizeof(*cap));
742 strcpy(cap->driver, "cx88_blackbird");
743 strlcpy(cap->card, cx88_boards[core->board].name,sizeof(cap->card));
744 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
745 cap->version = CX88_VERSION_CODE;
746 cap->capabilities =
747 V4L2_CAP_VIDEO_CAPTURE |
748 V4L2_CAP_READWRITE |
749 V4L2_CAP_STREAMING |
750 0;
751 if (UNSET != core->tuner_type)
752 cap->capabilities |= V4L2_CAP_TUNER;
753
754 return 0;
755 }
756
757 /* --- capture ioctls ---------------------------------------- */
758 case VIDIOC_ENUM_FMT:
759 {
760 struct v4l2_fmtdesc *f = arg;
761 int index;
762
763 index = f->index;
764 if (index != 0)
765 return -EINVAL;
766
767 memset(f,0,sizeof(*f));
768 f->index = index;
769 strlcpy(f->description, "MPEG", sizeof(f->description));
770 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
771 f->pixelformat = V4L2_PIX_FMT_MPEG;
772 return 0;
773 }
774 case VIDIOC_G_FMT:
775 {
776 struct v4l2_format *f = arg;
777
778 memset(f,0,sizeof(*f));
779 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
780 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
781 f->fmt.pix.bytesperline = 0;
782 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */
783 f->fmt.pix.colorspace = 0;
784 f->fmt.pix.width = dev->width;
785 f->fmt.pix.height = dev->height;
786 f->fmt.pix.field = fh->mpegq.field;
787 dprintk(0,"VIDIOC_G_FMT: w: %d, h: %d, f: %d\n",
788 dev->width, dev->height, fh->mpegq.field );
789 return 0;
790 }
791 case VIDIOC_TRY_FMT:
792 {
793 struct v4l2_format *f = arg;
794
795 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
796 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
797 f->fmt.pix.bytesperline = 0;
798 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */;
799 f->fmt.pix.colorspace = 0;
800 dprintk(0,"VIDIOC_TRY_FMT: w: %d, h: %d, f: %d\n",
801 dev->width, dev->height, fh->mpegq.field );
802 return 0;
803 }
804 case VIDIOC_S_FMT:
805 {
806 struct v4l2_format *f = arg;
807
808 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
809 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
810 f->fmt.pix.bytesperline = 0;
811 f->fmt.pix.sizeimage = dev->ts_packet_size * dev->ts_packet_count; /* 188 * 4 * 1024; */;
812 f->fmt.pix.colorspace = 0;
813 dprintk(0,"VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
814 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field );
815 return 0;
816 }
817
818 /* --- streaming capture ------------------------------------- */
819 case VIDIOC_REQBUFS:
820 return videobuf_reqbufs(&fh->mpegq, arg);
821
822 case VIDIOC_QUERYBUF:
823 return videobuf_querybuf(&fh->mpegq, arg);
824
825 case VIDIOC_QBUF:
826 return videobuf_qbuf(&fh->mpegq, arg);
827
828 case VIDIOC_DQBUF:
829 return videobuf_dqbuf(&fh->mpegq, arg,
830 file->f_flags & O_NONBLOCK);
831
832 case VIDIOC_STREAMON:
833 return videobuf_streamon(&fh->mpegq);
834
835 case VIDIOC_STREAMOFF:
836 return videobuf_streamoff(&fh->mpegq);
837
838 /* --- mpeg compression -------------------------------------- */
839 case VIDIOC_G_MPEGCOMP:
840 {
841 struct v4l2_mpeg_compression *f = arg;
842
843 printk(KERN_WARNING "VIDIOC_G_MPEGCOMP is obsolete. "
844 "Replace with VIDIOC_G_EXT_CTRLS!");
845 memcpy(f,&default_mpeg_params,sizeof(*f));
846 return 0;
847 }
848 case VIDIOC_S_MPEGCOMP:
849 printk(KERN_WARNING "VIDIOC_S_MPEGCOMP is obsolete. "
850 "Replace with VIDIOC_S_EXT_CTRLS!");
851 return 0;
852 case VIDIOC_G_EXT_CTRLS:
853 {
854 struct v4l2_ext_controls *f = arg;
855
856 if (f->ctrl_class != V4L2_CTRL_CLASS_MPEG)
857 return -EINVAL;
858 return cx2341x_ext_ctrls(&dev->params, f, cmd);
859 }
860 case VIDIOC_S_EXT_CTRLS:
861 case VIDIOC_TRY_EXT_CTRLS:
862 {
863 struct v4l2_ext_controls *f = arg;
864 struct cx2341x_mpeg_params p;
865 int err;
866
867 if (f->ctrl_class != V4L2_CTRL_CLASS_MPEG)
868 return -EINVAL;
869 p = dev->params;
870 err = cx2341x_ext_ctrls(&p, f, cmd);
871 if (err == 0 && cmd == VIDIOC_S_EXT_CTRLS) {
872 err = cx2341x_update(dev, blackbird_mbox_func, &dev->params, &p);
873 dev->params = p;
874 }
875 return err;
876 }
877 case VIDIOC_S_FREQUENCY:
878 {
879 blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
880 BLACKBIRD_END_NOW,
881 BLACKBIRD_MPEG_CAPTURE,
882 BLACKBIRD_RAW_BITS_NONE);
883
884 cx88_do_ioctl(inode, file, 0, dev->core, cmd, arg, cx88_ioctl_hook);
885
886 blackbird_initialize_codec(dev);
887 cx88_set_scale(dev->core, dev->width, dev->height,
888 fh->mpegq.field);
889 return 0;
890 }
891 case VIDIOC_LOG_STATUS:
892 {
893 char name[32 + 2];
894
895 snprintf(name, sizeof(name), "%s/2", core->name);
896 printk("%s/2: ============ START LOG STATUS ============\n",
897 core->name);
898 cx88_call_i2c_clients(core, VIDIOC_LOG_STATUS, NULL);
899 cx2341x_log_status(&dev->params, name);
900 printk("%s/2: ============= END LOG STATUS =============\n",
901 core->name);
902 return 0;
903 }
904 case VIDIOC_QUERYMENU:
905 return blackbird_querymenu(dev, arg);
906 case VIDIOC_QUERYCTRL:
907 {
908 struct v4l2_queryctrl *c = arg;
909
910 if (blackbird_queryctrl(dev, c) == 0)
911 return 0;
912 return cx88_do_ioctl(inode, file, 0, dev->core, cmd, arg, mpeg_do_ioctl);
913 }
914
915 default:
916 return cx88_do_ioctl(inode, file, 0, dev->core, cmd, arg, cx88_ioctl_hook);
917 }
918 return 0;
919 }
920
921 int (*cx88_ioctl_hook)(struct inode *inode, struct file *file,
922 unsigned int cmd, void *arg);
923 unsigned int (*cx88_ioctl_translator)(unsigned int cmd);
924
925 static unsigned int mpeg_translate_ioctl(unsigned int cmd)
926 {
927 return cmd;
928 }
929
930 static int mpeg_ioctl(struct inode *inode, struct file *file,
931 unsigned int cmd, unsigned long arg)
932 {
933 cmd = cx88_ioctl_translator( cmd );
934 return video_usercopy(inode, file, cmd, arg, cx88_ioctl_hook);
935 }
936
937 static int mpeg_open(struct inode *inode, struct file *file)
938 {
939 int minor = iminor(inode);
940 struct cx8802_dev *dev = NULL;
941 struct cx8802_fh *fh;
942 struct cx8802_driver *drv = NULL;
943 int err;
944
945 dprintk( 1, "%s\n", __FUNCTION__);
946
947 dev = cx8802_get_device(inode);
948 if (dev == NULL)
949 return -ENODEV;
950
951 /* Make sure we can acquire the hardware */
952 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
953 if (drv) {
954 err = drv->request_acquire(drv);
955 if(err != 0) {
956 dprintk(1,"%s: Unable to acquire hardware, %d\n", __FUNCTION__, err);
957 return err;
958 }
959 }
960
961 if (blackbird_initialize_codec(dev) < 0) {
962 if (drv)
963 drv->request_release(drv);
964 return -EINVAL;
965 }
966 dprintk(1,"open minor=%d\n",minor);
967
968 /* allocate + initialize per filehandle data */
969 fh = kzalloc(sizeof(*fh),GFP_KERNEL);
970 if (NULL == fh) {
971 if (drv)
972 drv->request_release(drv);
973 return -ENOMEM;
974 }
975 file->private_data = fh;
976 fh->dev = dev;
977
978 videobuf_queue_init(&fh->mpegq, &blackbird_qops,
979 dev->pci, &dev->slock,
980 V4L2_BUF_TYPE_VIDEO_CAPTURE,
981 V4L2_FIELD_INTERLACED,
982 sizeof(struct cx88_buffer),
983 fh);
984
985 /* FIXME: locking against other video device */
986 cx88_set_scale(dev->core, dev->width, dev->height,
987 fh->mpegq.field);
988
989 return 0;
990 }
991
992 static int mpeg_release(struct inode *inode, struct file *file)
993 {
994 struct cx8802_fh *fh = file->private_data;
995 struct cx8802_dev *dev = NULL;
996 struct cx8802_driver *drv = NULL;
997
998 /* blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0, BLACKBIRD_END_NOW, 0, 0x13); */
999 blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
1000 BLACKBIRD_END_NOW,
1001 BLACKBIRD_MPEG_CAPTURE,
1002 BLACKBIRD_RAW_BITS_NONE
1003 );
1004
1005 cx8802_cancel_buffers(fh->dev);
1006 /* stop mpeg capture */
1007 if (fh->mpegq.streaming)
1008 videobuf_streamoff(&fh->mpegq);
1009 if (fh->mpegq.reading)
1010 videobuf_read_stop(&fh->mpegq);
1011
1012 videobuf_mmap_free(&fh->mpegq);
1013 file->private_data = NULL;
1014 kfree(fh);
1015
1016 /* Make sure we release the hardware */
1017 dev = cx8802_get_device(inode);
1018 if (dev == NULL)
1019 return -ENODEV;
1020
1021 drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
1022 if (drv)
1023 drv->request_release(drv);
1024
1025 return 0;
1026 }
1027
1028 static ssize_t
1029 mpeg_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1030 {
1031 struct cx8802_fh *fh = file->private_data;
1032
1033 return videobuf_read_stream(&fh->mpegq, data, count, ppos, 0,
1034 file->f_flags & O_NONBLOCK);
1035 }
1036
1037 static unsigned int
1038 mpeg_poll(struct file *file, struct poll_table_struct *wait)
1039 {
1040 struct cx8802_fh *fh = file->private_data;
1041
1042 return videobuf_poll_stream(file, &fh->mpegq, wait);
1043 }
1044
1045 static int
1046 mpeg_mmap(struct file *file, struct vm_area_struct * vma)
1047 {
1048 struct cx8802_fh *fh = file->private_data;
1049
1050 return videobuf_mmap_mapper(&fh->mpegq, vma);
1051 }
1052
1053 static struct file_operations mpeg_fops =
1054 {
1055 .owner = THIS_MODULE,
1056 .open = mpeg_open,
1057 .release = mpeg_release,
1058 .read = mpeg_read,
1059 .poll = mpeg_poll,
1060 .mmap = mpeg_mmap,
1061 .ioctl = mpeg_ioctl,
1062 .llseek = no_llseek,
1063 };
1064
1065 static struct video_device cx8802_mpeg_template =
1066 {
1067 .name = "cx8802",
1068 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|VID_TYPE_SCALES|VID_TYPE_MPEG_ENCODER,
1069 .hardware = 0,
1070 .fops = &mpeg_fops,
1071 .minor = -1,
1072 };
1073
1074 /* ------------------------------------------------------------------ */
1075
1076 /* The CX8802 MPEG API will call this when we can use the hardware */
1077 static int cx8802_blackbird_advise_acquire(struct cx8802_driver *drv)
1078 {
1079 struct cx88_core *core = drv->core;
1080 int err = 0;
1081
1082 switch (core->board) {
1083 case CX88_BOARD_HAUPPAUGE_HVR1300:
1084 /* By default, core setup will leave the cx22702 out of reset, on the bus.
1085 * We left the hardware on power up with the cx22702 active.
1086 * We're being given access to re-arrange the GPIOs.
1087 * Take the bus off the cx22702 and put the cx23416 on it.
1088 */
1089 cx_clear(MO_GP0_IO, 0x00000080); /* cx22702 in reset */
1090 cx_set(MO_GP0_IO, 0x00000004); /* Disable the cx22702 */
1091 break;
1092 default:
1093 err = -ENODEV;
1094 }
1095 return err;
1096 }
1097
1098 /* The CX8802 MPEG API will call this when we need to release the hardware */
1099 static int cx8802_blackbird_advise_release(struct cx8802_driver *drv)
1100 {
1101 struct cx88_core *core = drv->core;
1102 int err = 0;
1103
1104 switch (core->board) {
1105 case CX88_BOARD_HAUPPAUGE_HVR1300:
1106 /* Exit leaving the cx23416 on the bus */
1107 break;
1108 default:
1109 err = -ENODEV;
1110 }
1111 return err;
1112 }
1113
1114 static void blackbird_unregister_video(struct cx8802_dev *dev)
1115 {
1116 if (dev->mpeg_dev) {
1117 if (-1 != dev->mpeg_dev->minor)
1118 video_unregister_device(dev->mpeg_dev);
1119 else
1120 video_device_release(dev->mpeg_dev);
1121 dev->mpeg_dev = NULL;
1122 }
1123 }
1124
1125 static int blackbird_register_video(struct cx8802_dev *dev)
1126 {
1127 int err;
1128
1129 dev->mpeg_dev = cx88_vdev_init(dev->core,dev->pci,
1130 &cx8802_mpeg_template,"mpeg");
1131 err = video_register_device(dev->mpeg_dev,VFL_TYPE_GRABBER, -1);
1132 if (err < 0) {
1133 printk(KERN_INFO "%s/2: can't register mpeg device\n",
1134 dev->core->name);
1135 return err;
1136 }
1137 printk(KERN_INFO "%s/2: registered device video%d [mpeg]\n",
1138 dev->core->name,dev->mpeg_dev->minor & 0x1f);
1139 return 0;
1140 }
1141
1142 /* ----------------------------------------------------------- */
1143
1144 static int cx8802_blackbird_probe(struct cx8802_driver *drv)
1145 {
1146 struct cx88_core *core = drv->core;
1147 struct cx8802_dev *dev = core->dvbdev;
1148 int err;
1149
1150 dprintk( 1, "%s\n", __FUNCTION__);
1151 dprintk( 1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n",
1152 core->board,
1153 core->name,
1154 core->pci_bus,
1155 core->pci_slot);
1156
1157 err = -ENODEV;
1158 if (!(cx88_boards[core->board].mpeg & CX88_MPEG_BLACKBIRD))
1159 goto fail_core;
1160
1161 dev->width = 720;
1162 dev->height = 576;
1163 cx2341x_fill_defaults(&dev->params);
1164 dev->params.port = CX2341X_PORT_STREAMING;
1165
1166 if (core->tvnorm->id & V4L2_STD_525_60) {
1167 dev->height = 480;
1168 } else {
1169 dev->height = 576;
1170 }
1171
1172 /* blackbird stuff */
1173 printk("%s/2: cx23416 based mpeg encoder (blackbird reference design)\n",
1174 core->name);
1175 host_setup(dev->core);
1176
1177 blackbird_register_video(dev);
1178
1179 /* initial device configuration: needed ? */
1180
1181 return 0;
1182
1183 fail_core:
1184 return err;
1185 }
1186
1187 static int cx8802_blackbird_remove(struct cx8802_driver *drv)
1188 {
1189 /* blackbird */
1190 blackbird_unregister_video(drv->core->dvbdev);
1191
1192 return 0;
1193 }
1194
1195 static struct cx8802_driver cx8802_blackbird_driver = {
1196 .type_id = CX88_MPEG_BLACKBIRD,
1197 .hw_access = CX8802_DRVCTL_SHARED,
1198 .probe = cx8802_blackbird_probe,
1199 .remove = cx8802_blackbird_remove,
1200 .advise_acquire = cx8802_blackbird_advise_acquire,
1201 .advise_release = cx8802_blackbird_advise_release,
1202 };
1203
1204 static int blackbird_init(void)
1205 {
1206 printk(KERN_INFO "cx2388x blackbird driver version %d.%d.%d loaded\n",
1207 (CX88_VERSION_CODE >> 16) & 0xff,
1208 (CX88_VERSION_CODE >> 8) & 0xff,
1209 CX88_VERSION_CODE & 0xff);
1210 #ifdef SNAPSHOT
1211 printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
1212 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
1213 #endif
1214 cx88_ioctl_hook = mpeg_do_ioctl;
1215 cx88_ioctl_translator = mpeg_translate_ioctl;
1216 return cx8802_register_driver(&cx8802_blackbird_driver);
1217 }
1218
1219 static void blackbird_fini(void)
1220 {
1221 cx8802_unregister_driver(&cx8802_blackbird_driver);
1222 }
1223
1224 module_init(blackbird_init);
1225 module_exit(blackbird_fini);
1226
1227 EXPORT_SYMBOL(cx88_ioctl_hook);
1228 EXPORT_SYMBOL(cx88_ioctl_translator);
1229
1230 /* ----------------------------------------------------------- */
1231 /*
1232 * Local variables:
1233 * c-basic-offset: 8
1234 * End:
1235 * kate: eol "unix"; indent-width 3; remove-trailing-space on; replace-trailing-space-save on; tab-width 8; replace-tabs off; space-indent off; mixed-indent off
1236 */
Support for the Chinese Samsung S3C2440 based development boards