2 * cx18 driver initialization and card probing
4 * Derived from ivtv-driver.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
25 #include "cx18-driver.h"
27 #include "cx18-version.h"
28 #include "cx18-cards.h"
31 #include "cx18-gpio.h"
32 #include "cx18-firmware.h"
33 #include "cx18-queue.h"
34 #include "cx18-streams.h"
35 #include "cx18-av-core.h"
37 #include "cx18-mailbox.h"
38 #include "cx18-ioctl.h"
39 #include "tuner-xc2028.h"
41 #include <media/tveeprom.h>
43 /* If you have already X v4l cards, then set this to X. This way
44 the device numbers stay matched. Example: you have a WinTV card
45 without radio and a Compro H900 with. Normally this would give a
46 video1 device together with a radio0 device for the Compro. By
47 setting this to 1 you ensure that radio0 is now also radio1. */
50 /* add your revision and whatnot here */
51 static struct pci_device_id cx18_pci_tbl
[] __devinitdata
= {
52 {PCI_VENDOR_ID_CX
, PCI_DEVICE_ID_CX23418
,
53 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
57 MODULE_DEVICE_TABLE(pci
, cx18_pci_tbl
);
59 static atomic_t cx18_instance
= ATOMIC_INIT(0);
61 /* Parameter declarations */
62 static int cardtype
[CX18_MAX_CARDS
];
63 static int tuner
[CX18_MAX_CARDS
] = { -1, -1, -1, -1, -1, -1, -1, -1,
64 -1, -1, -1, -1, -1, -1, -1, -1,
65 -1, -1, -1, -1, -1, -1, -1, -1,
66 -1, -1, -1, -1, -1, -1, -1, -1 };
67 static int radio
[CX18_MAX_CARDS
] = { -1, -1, -1, -1, -1, -1, -1, -1,
68 -1, -1, -1, -1, -1, -1, -1, -1,
69 -1, -1, -1, -1, -1, -1, -1, -1,
70 -1, -1, -1, -1, -1, -1, -1, -1 };
71 static unsigned cardtype_c
= 1;
72 static unsigned tuner_c
= 1;
73 static unsigned radio_c
= 1;
74 static char pal
[] = "--";
75 static char secam
[] = "--";
76 static char ntsc
[] = "-";
79 static int enc_ts_buffers
= CX18_DEFAULT_ENC_TS_BUFFERS
;
80 static int enc_mpg_buffers
= CX18_DEFAULT_ENC_MPG_BUFFERS
;
81 static int enc_idx_buffers
= CX18_DEFAULT_ENC_IDX_BUFFERS
;
82 static int enc_yuv_buffers
= CX18_DEFAULT_ENC_YUV_BUFFERS
;
83 static int enc_vbi_buffers
= CX18_DEFAULT_ENC_VBI_BUFFERS
;
84 static int enc_pcm_buffers
= CX18_DEFAULT_ENC_PCM_BUFFERS
;
86 static int enc_ts_bufsize
= CX18_DEFAULT_ENC_TS_BUFSIZE
;
87 static int enc_mpg_bufsize
= CX18_DEFAULT_ENC_MPG_BUFSIZE
;
88 static int enc_idx_bufsize
= CX18_DEFAULT_ENC_IDX_BUFSIZE
;
89 static int enc_yuv_bufsize
= CX18_DEFAULT_ENC_YUV_BUFSIZE
;
90 /* VBI bufsize based on standards supported by card tuner for now */
91 static int enc_pcm_bufsize
= CX18_DEFAULT_ENC_PCM_BUFSIZE
;
93 static int enc_ts_bufs
= -1;
94 static int enc_mpg_bufs
= -1;
95 static int enc_idx_bufs
= -1;
96 static int enc_yuv_bufs
= -1;
97 static int enc_vbi_bufs
= -1;
98 static int enc_pcm_bufs
= -1;
101 static int cx18_pci_latency
= 1;
103 static int mmio_ndelay
;
104 static int retry_mmio
= 1;
108 module_param_array(tuner
, int, &tuner_c
, 0644);
109 module_param_array(radio
, bool, &radio_c
, 0644);
110 module_param_array(cardtype
, int, &cardtype_c
, 0644);
111 module_param_string(pal
, pal
, sizeof(pal
), 0644);
112 module_param_string(secam
, secam
, sizeof(secam
), 0644);
113 module_param_string(ntsc
, ntsc
, sizeof(ntsc
), 0644);
114 module_param_named(debug
, cx18_debug
, int, 0644);
115 module_param(mmio_ndelay
, int, 0644);
116 module_param(retry_mmio
, int, 0644);
117 module_param(cx18_pci_latency
, int, 0644);
118 module_param(cx18_first_minor
, int, 0644);
120 module_param(enc_ts_buffers
, int, 0644);
121 module_param(enc_mpg_buffers
, int, 0644);
122 module_param(enc_idx_buffers
, int, 0644);
123 module_param(enc_yuv_buffers
, int, 0644);
124 module_param(enc_vbi_buffers
, int, 0644);
125 module_param(enc_pcm_buffers
, int, 0644);
127 module_param(enc_ts_bufsize
, int, 0644);
128 module_param(enc_mpg_bufsize
, int, 0644);
129 module_param(enc_idx_bufsize
, int, 0644);
130 module_param(enc_yuv_bufsize
, int, 0644);
131 /* VBI bufsize based on standards supported by card tuner for now */
132 module_param(enc_pcm_bufsize
, int, 0644);
134 module_param(enc_ts_bufs
, int, 0644);
135 module_param(enc_mpg_bufs
, int, 0644);
136 module_param(enc_idx_bufs
, int, 0644);
137 module_param(enc_yuv_bufs
, int, 0644);
138 module_param(enc_vbi_bufs
, int, 0644);
139 module_param(enc_pcm_bufs
, int, 0644);
141 MODULE_PARM_DESC(tuner
, "Tuner type selection,\n"
142 "\t\t\tsee tuner.h for values");
143 MODULE_PARM_DESC(radio
,
144 "Enable or disable the radio. Use only if autodetection\n"
145 "\t\t\tfails. 0 = disable, 1 = enable");
146 MODULE_PARM_DESC(cardtype
,
147 "Only use this option if your card is not detected properly.\n"
148 "\t\tSpecify card type:\n"
149 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
150 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
151 "\t\t\t 3 = Compro VideoMate H900\n"
152 "\t\t\t 4 = Yuan MPC718\n"
153 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
154 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
155 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
156 "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
157 "\t\t\t 0 = Autodetect (default)\n"
158 "\t\t\t-1 = Ignore this card\n\t\t");
159 MODULE_PARM_DESC(pal
, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
160 MODULE_PARM_DESC(secam
, "Set SECAM standard: B, G, H, D, K, L, LC");
161 MODULE_PARM_DESC(ntsc
, "Set NTSC standard: M, J, K");
162 MODULE_PARM_DESC(debug
,
163 "Debug level (bitmask). Default: 0\n"
164 "\t\t\t 1/0x0001: warning\n"
165 "\t\t\t 2/0x0002: info\n"
166 "\t\t\t 4/0x0004: mailbox\n"
167 "\t\t\t 8/0x0008: dma\n"
168 "\t\t\t 16/0x0010: ioctl\n"
169 "\t\t\t 32/0x0020: file\n"
170 "\t\t\t 64/0x0040: i2c\n"
171 "\t\t\t128/0x0080: irq\n"
172 "\t\t\t256/0x0100: high volume\n");
173 MODULE_PARM_DESC(cx18_pci_latency
,
174 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
175 "\t\t\tDefault: Yes");
176 MODULE_PARM_DESC(retry_mmio
,
177 "(Deprecated) MMIO writes are now always checked and retried\n"
178 "\t\t\tEffectively: 1 [Yes]");
179 MODULE_PARM_DESC(mmio_ndelay
,
180 "(Deprecated) MMIO accesses are now never purposely delayed\n"
181 "\t\t\tEffectively: 0 ns");
182 MODULE_PARM_DESC(enc_ts_buffers
,
183 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
184 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS
));
185 MODULE_PARM_DESC(enc_ts_bufsize
,
186 "Size of an encoder TS buffer (kB)\n"
187 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE
));
188 MODULE_PARM_DESC(enc_ts_bufs
,
189 "Number of encoder TS buffers\n"
190 "\t\t\tDefault is computed from other enc_ts_* parameters");
191 MODULE_PARM_DESC(enc_mpg_buffers
,
192 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
193 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS
));
194 MODULE_PARM_DESC(enc_mpg_bufsize
,
195 "Size of an encoder MPG buffer (kB)\n"
196 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE
));
197 MODULE_PARM_DESC(enc_mpg_bufs
,
198 "Number of encoder MPG buffers\n"
199 "\t\t\tDefault is computed from other enc_mpg_* parameters");
200 MODULE_PARM_DESC(enc_idx_buffers
,
201 "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
202 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS
));
203 MODULE_PARM_DESC(enc_idx_bufsize
,
204 "Size of an encoder IDX buffer (kB)\n"
205 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE
));
206 MODULE_PARM_DESC(enc_idx_bufs
,
207 "Number of encoder IDX buffers\n"
208 "\t\t\tDefault is computed from other enc_idx_* parameters");
209 MODULE_PARM_DESC(enc_yuv_buffers
,
210 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
211 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS
));
212 MODULE_PARM_DESC(enc_yuv_bufsize
,
213 "Size of an encoder YUV buffer (kB)\n"
214 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFSIZE
));
215 MODULE_PARM_DESC(enc_yuv_bufs
,
216 "Number of encoder YUV buffers\n"
217 "\t\t\tDefault is computed from other enc_yuv_* parameters");
218 MODULE_PARM_DESC(enc_vbi_buffers
,
219 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
220 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS
));
221 MODULE_PARM_DESC(enc_vbi_bufs
,
222 "Number of encoder VBI buffers\n"
223 "\t\t\tDefault is computed from enc_vbi_buffers & tuner std");
224 MODULE_PARM_DESC(enc_pcm_buffers
,
225 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
226 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS
));
227 MODULE_PARM_DESC(enc_pcm_bufsize
,
228 "Size of an encoder PCM buffer (kB)\n"
229 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE
));
230 MODULE_PARM_DESC(enc_pcm_bufs
,
231 "Number of encoder PCM buffers\n"
232 "\t\t\tDefault is computed from other enc_pcm_* parameters");
234 MODULE_PARM_DESC(cx18_first_minor
, "Set device node number assigned to first card");
236 MODULE_AUTHOR("Hans Verkuil");
237 MODULE_DESCRIPTION("CX23418 driver");
238 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
239 MODULE_LICENSE("GPL");
241 MODULE_VERSION(CX18_VERSION
);
243 /* Generic utility functions */
244 int cx18_msleep_timeout(unsigned int msecs
, int intr
)
246 long int timeout
= msecs_to_jiffies(msecs
);
250 set_current_state(intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
251 timeout
= schedule_timeout(timeout
);
252 sig
= intr
? signal_pending(current
) : 0;
253 } while (!sig
&& timeout
);
257 /* Release ioremapped memory */
258 static void cx18_iounmap(struct cx18
*cx
)
263 /* Release io memory */
264 if (cx
->enc_mem
!= NULL
) {
265 CX18_DEBUG_INFO("releasing enc_mem\n");
266 iounmap(cx
->enc_mem
);
271 static void cx18_eeprom_dump(struct cx18
*cx
, unsigned char *eedata
, int len
)
275 CX18_INFO("eeprom dump:\n");
276 for (i
= 0; i
< len
; i
++) {
278 CX18_INFO("eeprom %02x:", i
);
279 printk(KERN_CONT
" %02x", eedata
[i
]);
281 printk(KERN_CONT
"\n");
285 /* Hauppauge card? get values from tveeprom */
286 void cx18_read_eeprom(struct cx18
*cx
, struct tveeprom
*tv
)
291 memset(&c
, 0, sizeof(c
));
292 strlcpy(c
.name
, "cx18 tveeprom tmp", sizeof(c
.name
));
293 c
.adapter
= &cx
->i2c_adap
[0];
296 memset(tv
, 0, sizeof(*tv
));
297 if (tveeprom_read(&c
, eedata
, sizeof(eedata
)))
300 switch (cx
->card
->type
) {
301 case CX18_CARD_HVR_1600_ESMT
:
302 case CX18_CARD_HVR_1600_SAMSUNG
:
303 tveeprom_hauppauge_analog(&c
, tv
, eedata
);
305 case CX18_CARD_YUAN_MPC718
:
307 cx18_eeprom_dump(cx
, eedata
, sizeof(eedata
));
308 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
309 eedata
[2], eedata
[1], eedata
[4], eedata
[3]);
312 tv
->model
= 0xffffffff;
313 cx18_eeprom_dump(cx
, eedata
, sizeof(eedata
));
318 static void cx18_process_eeprom(struct cx18
*cx
)
322 cx18_read_eeprom(cx
, &tv
);
324 /* Many thanks to Steven Toth from Hauppauge for providing the
326 /* Note: the Samsung memory models cannot be reliably determined
327 from the model number. Use the cardtype module option if you
328 have one of these preproduction models. */
330 case 74000 ... 74999:
331 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
336 CX18_INFO("Unknown EEPROM encoding\n");
339 CX18_ERR("Invalid EEPROM\n");
342 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv
.model
);
343 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
347 cx
->v4l2_cap
= cx
->card
->v4l2_capabilities
;
348 cx
->card_name
= cx
->card
->name
;
349 cx
->card_i2c
= cx
->card
->i2c
;
351 CX18_INFO("Autodetected %s\n", cx
->card_name
);
353 if (tv
.tuner_type
== TUNER_ABSENT
)
354 CX18_ERR("tveeprom cannot autodetect tuner!\n");
356 if (cx
->options
.tuner
== -1)
357 cx
->options
.tuner
= tv
.tuner_type
;
358 if (cx
->options
.radio
== -1)
359 cx
->options
.radio
= (tv
.has_radio
!= 0);
362 /* user specified tuner standard */
365 /* autodetect tuner standard */
366 if (tv
.tuner_formats
& V4L2_STD_PAL
) {
367 CX18_DEBUG_INFO("PAL tuner detected\n");
368 cx
->std
|= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
369 } else if (tv
.tuner_formats
& V4L2_STD_NTSC
) {
370 CX18_DEBUG_INFO("NTSC tuner detected\n");
371 cx
->std
|= V4L2_STD_NTSC_M
;
372 } else if (tv
.tuner_formats
& V4L2_STD_SECAM
) {
373 CX18_DEBUG_INFO("SECAM tuner detected\n");
374 cx
->std
|= V4L2_STD_SECAM_L
;
376 CX18_INFO("No tuner detected, default to NTSC-M\n");
377 cx
->std
|= V4L2_STD_NTSC_M
;
381 static v4l2_std_id
cx18_parse_std(struct cx18
*cx
)
385 return V4L2_STD_PAL_60
;
390 return V4L2_STD_PAL_BG
;
393 return V4L2_STD_PAL_H
;
396 if (pal
[1] == 'c' || pal
[1] == 'C')
397 return V4L2_STD_PAL_Nc
;
398 return V4L2_STD_PAL_N
;
401 return V4L2_STD_PAL_I
;
406 return V4L2_STD_PAL_DK
;
409 return V4L2_STD_PAL_M
;
413 CX18_WARN("pal= argument not recognised\n");
424 return V4L2_STD_SECAM_B
| V4L2_STD_SECAM_G
| V4L2_STD_SECAM_H
;
429 return V4L2_STD_SECAM_DK
;
432 if (secam
[1] == 'C' || secam
[1] == 'c')
433 return V4L2_STD_SECAM_LC
;
434 return V4L2_STD_SECAM_L
;
438 CX18_WARN("secam= argument not recognised\n");
445 return V4L2_STD_NTSC_M
;
448 return V4L2_STD_NTSC_M_JP
;
451 return V4L2_STD_NTSC_M_KR
;
455 CX18_WARN("ntsc= argument not recognised\n");
463 static void cx18_process_options(struct cx18
*cx
)
467 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_buffers
;
468 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_buffers
;
469 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_buffers
;
470 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_buffers
;
471 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_VBI
] = enc_vbi_buffers
;
472 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_buffers
;
473 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control only */
475 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_bufs
;
476 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_bufs
;
477 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_bufs
;
478 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_bufs
;
479 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_VBI
] = enc_vbi_bufs
;
480 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_bufs
;
481 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control, no data */
483 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_bufsize
;
484 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_bufsize
;
485 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_bufsize
;
486 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_bufsize
;
487 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_VBI
] = vbi_active_samples
* 36;
488 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_bufsize
;
489 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control no data */
491 /* Ensure stream_buffers & stream_buf_size are valid */
492 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
493 if (cx
->stream_buffers
[i
] == 0 || /* User said 0 buffers */
494 cx
->options
.megabytes
[i
] <= 0 || /* User said 0 MB total */
495 cx
->stream_buf_size
[i
] <= 0) { /* User said buf size 0 */
496 cx
->options
.megabytes
[i
] = 0;
497 cx
->stream_buffers
[i
] = 0;
498 cx
->stream_buf_size
[i
] = 0;
502 * VBI is a special case where the stream_buf_size is fixed
503 * and already in bytes
505 if (i
== CX18_ENC_STREAM_TYPE_VBI
) {
506 if (cx
->stream_buffers
[i
] < 0) {
507 cx
->stream_buffers
[i
] =
508 cx
->options
.megabytes
[i
] * 1024 * 1024
509 / cx
->stream_buf_size
[i
];
511 /* N.B. This might round down to 0 */
512 cx
->options
.megabytes
[i
] =
513 cx
->stream_buffers
[i
]
514 * cx
->stream_buf_size
[i
]/(1024 * 1024);
518 /* All other streams have stream_buf_size in kB at this point */
519 if (cx
->stream_buffers
[i
] < 0) {
520 cx
->stream_buffers
[i
] = cx
->options
.megabytes
[i
] * 1024
521 / cx
->stream_buf_size
[i
];
523 /* N.B. This might round down to 0 */
524 cx
->options
.megabytes
[i
] =
525 cx
->stream_buffers
[i
] * cx
->stream_buf_size
[i
] / 1024;
527 cx
->stream_buf_size
[i
] *= 1024; /* convert from kB to bytes */
530 cx
->options
.cardtype
= cardtype
[cx
->instance
];
531 cx
->options
.tuner
= tuner
[cx
->instance
];
532 cx
->options
.radio
= radio
[cx
->instance
];
534 cx
->std
= cx18_parse_std(cx
);
535 if (cx
->options
.cardtype
== -1) {
536 CX18_INFO("Ignore card\n");
539 cx
->card
= cx18_get_card(cx
->options
.cardtype
- 1);
541 CX18_INFO("User specified %s card\n", cx
->card
->name
);
542 else if (cx
->options
.cardtype
!= 0)
543 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
544 if (cx
->card
== NULL
) {
545 if (cx
->pci_dev
->subsystem_vendor
== CX18_PCI_ID_HAUPPAUGE
) {
546 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
547 CX18_INFO("Autodetected Hauppauge card\n");
550 if (cx
->card
== NULL
) {
551 for (i
= 0; (cx
->card
= cx18_get_card(i
)); i
++) {
552 if (cx
->card
->pci_list
== NULL
)
554 for (j
= 0; cx
->card
->pci_list
[j
].device
; j
++) {
555 if (cx
->pci_dev
->device
!=
556 cx
->card
->pci_list
[j
].device
)
558 if (cx
->pci_dev
->subsystem_vendor
!=
559 cx
->card
->pci_list
[j
].subsystem_vendor
)
561 if (cx
->pci_dev
->subsystem_device
!=
562 cx
->card
->pci_list
[j
].subsystem_device
)
564 CX18_INFO("Autodetected %s card\n", cx
->card
->name
);
571 if (cx
->card
== NULL
) {
572 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
573 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
574 cx
->pci_dev
->vendor
, cx
->pci_dev
->device
);
575 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
576 cx
->pci_dev
->subsystem_vendor
,
577 cx
->pci_dev
->subsystem_device
);
578 CX18_ERR("Defaulting to %s card\n", cx
->card
->name
);
579 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
580 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
581 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
583 cx
->v4l2_cap
= cx
->card
->v4l2_capabilities
;
584 cx
->card_name
= cx
->card
->name
;
585 cx
->card_i2c
= cx
->card
->i2c
;
588 static int __devinit
cx18_create_in_workq(struct cx18
*cx
)
590 snprintf(cx
->in_workq_name
, sizeof(cx
->in_workq_name
), "%s-in",
592 cx
->in_work_queue
= create_singlethread_workqueue(cx
->in_workq_name
);
593 if (cx
->in_work_queue
== NULL
) {
594 CX18_ERR("Unable to create incoming mailbox handler thread\n");
600 static int __devinit
cx18_create_out_workq(struct cx18
*cx
)
602 snprintf(cx
->out_workq_name
, sizeof(cx
->out_workq_name
), "%s-out",
604 cx
->out_work_queue
= create_workqueue(cx
->out_workq_name
);
605 if (cx
->out_work_queue
== NULL
) {
606 CX18_ERR("Unable to create outgoing mailbox handler threads\n");
612 static void __devinit
cx18_init_in_work_orders(struct cx18
*cx
)
615 for (i
= 0; i
< CX18_MAX_IN_WORK_ORDERS
; i
++) {
616 cx
->in_work_order
[i
].cx
= cx
;
617 cx
->in_work_order
[i
].str
= cx
->epu_debug_str
;
618 INIT_WORK(&cx
->in_work_order
[i
].work
, cx18_in_work_handler
);
622 /* Precondition: the cx18 structure has been memset to 0. Only
623 the dev and instance fields have been filled in.
624 No assumptions on the card type may be made here (see cx18_init_struct2
627 static int __devinit
cx18_init_struct1(struct cx18
*cx
)
631 cx
->base_addr
= pci_resource_start(cx
->pci_dev
, 0);
633 mutex_init(&cx
->serialize_lock
);
634 mutex_init(&cx
->gpio_lock
);
635 mutex_init(&cx
->epu2apu_mb_lock
);
636 mutex_init(&cx
->epu2cpu_mb_lock
);
638 ret
= cx18_create_out_workq(cx
);
642 ret
= cx18_create_in_workq(cx
);
644 destroy_workqueue(cx
->out_work_queue
);
648 cx18_init_in_work_orders(cx
);
650 /* start counting open_id at 1 */
653 /* Initial settings */
654 cx2341x_fill_defaults(&cx
->params
);
655 cx
->temporal_strength
= cx
->params
.video_temporal_filter
;
656 cx
->spatial_strength
= cx
->params
.video_spatial_filter
;
657 cx
->filter_mode
= cx
->params
.video_spatial_filter_mode
|
658 (cx
->params
.video_temporal_filter_mode
<< 1) |
659 (cx
->params
.video_median_filter_type
<< 2);
660 cx
->params
.port
= CX2341X_PORT_MEMORY
;
661 cx
->params
.capabilities
=
662 CX2341X_CAP_HAS_TS
| CX2341X_CAP_HAS_SLICED_VBI
;
663 init_waitqueue_head(&cx
->cap_w
);
664 init_waitqueue_head(&cx
->mb_apu_waitq
);
665 init_waitqueue_head(&cx
->mb_cpu_waitq
);
666 init_waitqueue_head(&cx
->dma_waitq
);
669 cx
->vbi
.in
.type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
670 cx
->vbi
.sliced_in
= &cx
->vbi
.in
.fmt
.sliced
;
675 /* Second initialization part. Here the card type has been
677 static void __devinit
cx18_init_struct2(struct cx18
*cx
)
681 for (i
= 0; i
< CX18_CARD_MAX_VIDEO_INPUTS
; i
++)
682 if (cx
->card
->video_inputs
[i
].video_type
== 0)
685 for (i
= 0; i
< CX18_CARD_MAX_AUDIO_INPUTS
; i
++)
686 if (cx
->card
->audio_inputs
[i
].audio_type
== 0)
688 cx
->nof_audio_inputs
= i
;
690 /* Find tuner input */
691 for (i
= 0; i
< cx
->nof_inputs
; i
++) {
692 if (cx
->card
->video_inputs
[i
].video_type
==
693 CX18_CARD_INPUT_VID_TUNER
)
696 if (i
== cx
->nof_inputs
)
698 cx
->active_input
= i
;
699 cx
->audio_input
= cx
->card
->video_inputs
[i
].audio_index
;
702 static int cx18_setup_pci(struct cx18
*cx
, struct pci_dev
*pci_dev
,
703 const struct pci_device_id
*pci_id
)
706 unsigned char pci_latency
;
708 CX18_DEBUG_INFO("Enabling pci device\n");
710 if (pci_enable_device(pci_dev
)) {
711 CX18_ERR("Can't enable device %d!\n", cx
->instance
);
714 if (pci_set_dma_mask(pci_dev
, 0xffffffff)) {
715 CX18_ERR("No suitable DMA available, card %d\n", cx
->instance
);
718 if (!request_mem_region(cx
->base_addr
, CX18_MEM_SIZE
, "cx18 encoder")) {
719 CX18_ERR("Cannot request encoder memory region, card %d\n",
724 /* Enable bus mastering and memory mapped IO for the CX23418 */
725 pci_read_config_word(pci_dev
, PCI_COMMAND
, &cmd
);
726 cmd
|= PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
;
727 pci_write_config_word(pci_dev
, PCI_COMMAND
, cmd
);
729 pci_read_config_byte(pci_dev
, PCI_CLASS_REVISION
, &cx
->card_rev
);
730 pci_read_config_byte(pci_dev
, PCI_LATENCY_TIMER
, &pci_latency
);
732 if (pci_latency
< 64 && cx18_pci_latency
) {
733 CX18_INFO("Unreasonably low latency timer, "
734 "setting to 64 (was %d)\n", pci_latency
);
735 pci_write_config_byte(pci_dev
, PCI_LATENCY_TIMER
, 64);
736 pci_read_config_byte(pci_dev
, PCI_LATENCY_TIMER
, &pci_latency
);
739 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
740 "irq: %d, latency: %d, memory: 0x%lx\n",
741 cx
->pci_dev
->device
, cx
->card_rev
, pci_dev
->bus
->number
,
742 PCI_SLOT(pci_dev
->devfn
), PCI_FUNC(pci_dev
->devfn
),
743 cx
->pci_dev
->irq
, pci_latency
, (unsigned long)cx
->base_addr
);
748 static void cx18_init_subdevs(struct cx18
*cx
)
750 u32 hw
= cx
->card
->hw_all
;
754 for (i
= 0, device
= 1; i
< 32; i
++, device
<<= 1) {
761 case CX18_HW_TVEEPROM
:
762 /* These subordinate devices do not use probing */
763 cx
->hw_flags
|= device
;
766 /* The A/V decoder gets probed earlier to set PLLs */
767 /* Just note that the card uses it (i.e. has analog) */
768 cx
->hw_flags
|= device
;
770 case CX18_HW_GPIO_RESET_CTRL
:
772 * The Reset Controller gets probed and added to
773 * hw_flags earlier for i2c adapter/bus initialization
776 case CX18_HW_GPIO_MUX
:
777 if (cx18_gpio_register(cx
, device
) == 0)
778 cx
->hw_flags
|= device
;
781 if (cx18_i2c_register(cx
, i
) == 0)
782 cx
->hw_flags
|= device
;
787 if (cx
->hw_flags
& CX18_HW_418_AV
)
788 cx
->sd_av
= cx18_find_hw(cx
, CX18_HW_418_AV
);
790 if (cx
->card
->hw_muxer
!= 0)
791 cx
->sd_extmux
= cx18_find_hw(cx
, cx
->card
->hw_muxer
);
794 static int __devinit
cx18_probe(struct pci_dev
*pci_dev
,
795 const struct pci_device_id
*pci_id
)
802 /* FIXME - module parameter arrays constrain max instances */
803 i
= atomic_inc_return(&cx18_instance
) - 1;
804 if (i
>= CX18_MAX_CARDS
) {
805 printk(KERN_ERR
"cx18: cannot manage card %d, driver has a "
806 "limit of 0 - %d\n", i
, CX18_MAX_CARDS
- 1);
810 cx
= kzalloc(sizeof(struct cx18
), GFP_ATOMIC
);
812 printk(KERN_ERR
"cx18: cannot manage card %d, out of memory\n",
816 cx
->pci_dev
= pci_dev
;
819 retval
= v4l2_device_register(&pci_dev
->dev
, &cx
->v4l2_dev
);
821 printk(KERN_ERR
"cx18: v4l2_device_register of card %d failed"
826 snprintf(cx
->v4l2_dev
.name
, sizeof(cx
->v4l2_dev
.name
), "cx18-%d",
828 CX18_INFO("Initializing card %d\n", cx
->instance
);
830 cx18_process_options(cx
);
831 if (cx
->options
.cardtype
== -1) {
836 retval
= cx18_init_struct1(cx
);
840 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx
->base_addr
);
842 /* PCI Device Setup */
843 retval
= cx18_setup_pci(cx
, pci_dev
, pci_id
);
845 goto free_workqueues
;
848 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
849 cx
->base_addr
+ CX18_MEM_OFFSET
, CX18_MEM_SIZE
);
850 cx
->enc_mem
= ioremap_nocache(cx
->base_addr
+ CX18_MEM_OFFSET
,
853 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
854 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
858 cx
->reg_mem
= cx
->enc_mem
+ CX18_REG_OFFSET
;
859 devtype
= cx18_read_reg(cx
, 0xC72028);
860 switch (devtype
& 0xff000000) {
862 CX18_INFO("cx23418 revision %08x (A)\n", devtype
);
865 CX18_INFO("cx23418 revision %08x (B)\n", devtype
);
868 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype
);
872 cx18_init_power(cx
, 1);
873 cx18_init_memory(cx
);
875 cx
->scb
= (struct cx18_scb __iomem
*)(cx
->enc_mem
+ SCB_OFFSET
);
880 /* Initialize integrated A/V decoder early to set PLLs, just in case */
881 retval
= cx18_av_probe(cx
);
883 CX18_ERR("Could not register A/V decoder subdevice\n");
886 cx18_call_hw(cx
, CX18_HW_418_AV
, core
, init
, 0);
888 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
889 if (cx
->card
->hw_all
& CX18_HW_GPIO_RESET_CTRL
) {
890 if (cx18_gpio_register(cx
, CX18_HW_GPIO_RESET_CTRL
) != 0)
891 CX18_WARN("Could not register GPIO reset controller"
892 "subdevice; proceeding anyway.\n");
894 cx
->hw_flags
|= CX18_HW_GPIO_RESET_CTRL
;
898 CX18_DEBUG_INFO("activating i2c...\n");
899 retval
= init_cx18_i2c(cx
);
901 CX18_ERR("Could not initialize i2c\n");
905 if (cx
->card
->hw_all
& CX18_HW_TVEEPROM
) {
906 /* Based on the model number the cardtype may be changed.
907 The PCI IDs are not always reliable. */
908 cx18_process_eeprom(cx
);
910 if (cx
->card
->comment
)
911 CX18_INFO("%s", cx
->card
->comment
);
912 if (cx
->card
->v4l2_capabilities
== 0) {
916 cx18_init_memory(cx
);
920 retval
= request_irq(cx
->pci_dev
->irq
, cx18_irq_handler
,
921 IRQF_SHARED
| IRQF_DISABLED
,
922 cx
->v4l2_dev
.name
, (void *)cx
);
924 CX18_ERR("Failed to register irq %d\n", retval
);
929 cx
->std
= V4L2_STD_NTSC_M
;
931 if (cx
->options
.tuner
== -1) {
932 for (i
= 0; i
< CX18_CARD_MAX_TUNERS
; i
++) {
933 if ((cx
->std
& cx
->card
->tuners
[i
].std
) == 0)
935 cx
->options
.tuner
= cx
->card
->tuners
[i
].tuner
;
939 /* if no tuner was found, then pick the first tuner in the card list */
940 if (cx
->options
.tuner
== -1 && cx
->card
->tuners
[0].std
) {
941 cx
->std
= cx
->card
->tuners
[0].std
;
942 if (cx
->std
& V4L2_STD_PAL
)
943 cx
->std
= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
944 else if (cx
->std
& V4L2_STD_NTSC
)
945 cx
->std
= V4L2_STD_NTSC_M
;
946 else if (cx
->std
& V4L2_STD_SECAM
)
947 cx
->std
= V4L2_STD_SECAM_L
;
948 cx
->options
.tuner
= cx
->card
->tuners
[0].tuner
;
950 if (cx
->options
.radio
== -1)
951 cx
->options
.radio
= (cx
->card
->radio_input
.audio_type
!= 0);
953 /* The card is now fully identified, continue with card-specific
955 cx18_init_struct2(cx
);
957 cx18_init_subdevs(cx
);
959 if (cx
->std
& V4L2_STD_525_60
)
964 cx
->params
.video_gop_size
= cx
->is_60hz
? 15 : 12;
966 if (cx
->options
.radio
> 0)
967 cx
->v4l2_cap
|= V4L2_CAP_RADIO
;
969 if (cx
->options
.tuner
> -1) {
970 struct tuner_setup setup
;
972 setup
.addr
= ADDR_UNSET
;
973 setup
.type
= cx
->options
.tuner
;
974 setup
.mode_mask
= T_ANALOG_TV
; /* matches TV tuners */
975 setup
.tuner_callback
= (setup
.type
== TUNER_XC2028
) ?
976 cx18_reset_tuner_gpio
: NULL
;
977 cx18_call_all(cx
, tuner
, s_type_addr
, &setup
);
978 if (setup
.type
== TUNER_XC2028
) {
979 static struct xc2028_ctrl ctrl
= {
980 .fname
= XC2028_DEFAULT_FIRMWARE
,
983 struct v4l2_priv_tun_config cfg
= {
984 .tuner
= cx
->options
.tuner
,
987 cx18_call_all(cx
, tuner
, s_config
, &cfg
);
991 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
993 cx
->tuner_std
= cx
->std
;
995 retval
= cx18_streams_setup(cx
);
997 CX18_ERR("Error %d setting up streams\n", retval
);
1000 retval
= cx18_streams_register(cx
);
1002 CX18_ERR("Error %d registering devices\n", retval
);
1006 CX18_INFO("Initialized card: %s\n", cx
->card_name
);
1010 cx18_streams_cleanup(cx
, 1);
1012 free_irq(cx
->pci_dev
->irq
, (void *)cx
);
1018 release_mem_region(cx
->base_addr
, CX18_MEM_SIZE
);
1020 destroy_workqueue(cx
->in_work_queue
);
1021 destroy_workqueue(cx
->out_work_queue
);
1025 CX18_ERR("Error %d on initialization\n", retval
);
1027 v4l2_device_unregister(&cx
->v4l2_dev
);
1032 int cx18_init_on_first_open(struct cx18
*cx
)
1035 int fw_retry_count
= 3;
1036 struct v4l2_frequency vf
;
1037 struct cx18_open_id fh
;
1041 if (test_bit(CX18_F_I_FAILED
, &cx
->i_flags
))
1044 if (test_and_set_bit(CX18_F_I_INITED
, &cx
->i_flags
))
1047 while (--fw_retry_count
> 0) {
1049 if (cx18_firmware_init(cx
) == 0)
1051 if (fw_retry_count
> 1)
1052 CX18_WARN("Retry loading firmware\n");
1055 if (fw_retry_count
== 0) {
1056 set_bit(CX18_F_I_FAILED
, &cx
->i_flags
);
1059 set_bit(CX18_F_I_LOADED_FW
, &cx
->i_flags
);
1062 * Init the firmware twice to work around a silicon bug
1063 * with the digital TS.
1065 * The second firmware load requires us to normalize the APU state,
1066 * or the audio for the first analog capture will be badly incorrect.
1068 * I can't seem to call APU_RESETAI and have it succeed without the
1069 * APU capturing audio, so we start and stop it here to do the reset
1072 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1073 cx18_vapi(cx
, CX18_APU_START
, 2, CX18_APU_ENCODING_METHOD_MPEG
|0xb9, 0);
1074 cx18_vapi(cx
, CX18_APU_RESETAI
, 0);
1075 cx18_vapi(cx
, CX18_APU_STOP
, 1, CX18_APU_ENCODING_METHOD_MPEG
);
1078 while (--fw_retry_count
> 0) {
1080 if (cx18_firmware_init(cx
) == 0)
1082 if (fw_retry_count
> 1)
1083 CX18_WARN("Retry loading firmware\n");
1086 if (fw_retry_count
== 0) {
1087 set_bit(CX18_F_I_FAILED
, &cx
->i_flags
);
1092 * The second firmware load requires us to normalize the APU state,
1093 * or the audio for the first analog capture will be badly incorrect.
1095 * I can't seem to call APU_RESETAI and have it succeed without the
1096 * APU capturing audio, so we start and stop it here to do the reset
1099 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1100 cx18_vapi(cx
, CX18_APU_START
, 2, CX18_APU_ENCODING_METHOD_MPEG
|0xb9, 0);
1101 cx18_vapi(cx
, CX18_APU_RESETAI
, 0);
1102 cx18_vapi(cx
, CX18_APU_STOP
, 1, CX18_APU_ENCODING_METHOD_MPEG
);
1104 /* Init the A/V decoder, if it hasn't been already */
1105 v4l2_subdev_call(cx
->sd_av
, core
, load_fw
);
1108 vf
.type
= V4L2_TUNER_ANALOG_TV
;
1109 vf
.frequency
= 6400; /* the tuner 'baseline' frequency */
1111 /* Set initial frequency. For PAL/SECAM broadcasts no
1112 'default' channel exists AFAIK. */
1113 if (cx
->std
== V4L2_STD_NTSC_M_JP
)
1114 vf
.frequency
= 1460; /* ch. 1 91250*16/1000 */
1115 else if (cx
->std
& V4L2_STD_NTSC_M
)
1116 vf
.frequency
= 1076; /* ch. 4 67250*16/1000 */
1118 video_input
= cx
->active_input
;
1119 cx
->active_input
++; /* Force update of input */
1120 cx18_s_input(NULL
, &fh
, video_input
);
1122 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1124 cx
->std
++; /* Force full standard initialization */
1125 cx18_s_std(NULL
, &fh
, &cx
->tuner_std
);
1126 cx18_s_frequency(NULL
, &fh
, &vf
);
1130 static void cx18_cancel_in_work_orders(struct cx18
*cx
)
1133 for (i
= 0; i
< CX18_MAX_IN_WORK_ORDERS
; i
++)
1134 cancel_work_sync(&cx
->in_work_order
[i
].work
);
1137 static void cx18_cancel_out_work_orders(struct cx18
*cx
)
1140 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++)
1141 if (&cx
->streams
[i
].video_dev
!= NULL
)
1142 cancel_work_sync(&cx
->streams
[i
].out_work_order
);
1145 static void cx18_remove(struct pci_dev
*pci_dev
)
1147 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pci_dev
);
1148 struct cx18
*cx
= to_cx18(v4l2_dev
);
1151 CX18_DEBUG_INFO("Removing Card\n");
1153 /* Stop all captures */
1154 CX18_DEBUG_INFO("Stopping all streams\n");
1155 if (atomic_read(&cx
->tot_capturing
) > 0)
1156 cx18_stop_all_captures(cx
);
1158 /* Stop interrupts that cause incoming work to be queued */
1159 cx18_sw1_irq_disable(cx
, IRQ_CPU_TO_EPU
| IRQ_APU_TO_EPU
);
1161 /* Incoming work can cause outgoing work, so clean up incoming first */
1162 cx18_cancel_in_work_orders(cx
);
1163 cx18_cancel_out_work_orders(cx
);
1165 /* Stop ack interrupts that may have been needed for work to finish */
1166 cx18_sw2_irq_disable(cx
, IRQ_CPU_TO_EPU_ACK
| IRQ_APU_TO_EPU_ACK
);
1168 cx18_halt_firmware(cx
);
1170 destroy_workqueue(cx
->in_work_queue
);
1171 destroy_workqueue(cx
->out_work_queue
);
1173 cx18_streams_cleanup(cx
, 1);
1177 free_irq(cx
->pci_dev
->irq
, (void *)cx
);
1181 release_mem_region(cx
->base_addr
, CX18_MEM_SIZE
);
1183 pci_disable_device(cx
->pci_dev
);
1185 if (cx
->vbi
.sliced_mpeg_data
[0] != NULL
)
1186 for (i
= 0; i
< CX18_VBI_FRAMES
; i
++)
1187 kfree(cx
->vbi
.sliced_mpeg_data
[i
]);
1189 CX18_INFO("Removed %s\n", cx
->card_name
);
1191 v4l2_device_unregister(v4l2_dev
);
1195 /* define a pci_driver for card detection */
1196 static struct pci_driver cx18_pci_driver
= {
1198 .id_table
= cx18_pci_tbl
,
1199 .probe
= cx18_probe
,
1200 .remove
= cx18_remove
,
1203 static int module_start(void)
1205 printk(KERN_INFO
"cx18: Start initialization, version %s\n", CX18_VERSION
);
1207 /* Validate parameters */
1208 if (cx18_first_minor
< 0 || cx18_first_minor
>= CX18_MAX_CARDS
) {
1209 printk(KERN_ERR
"cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1210 CX18_MAX_CARDS
- 1);
1214 if (cx18_debug
< 0 || cx18_debug
> 511) {
1216 printk(KERN_INFO
"cx18: Debug value must be >= 0 and <= 511!\n");
1219 if (pci_register_driver(&cx18_pci_driver
)) {
1220 printk(KERN_ERR
"cx18: Error detecting PCI card\n");
1223 printk(KERN_INFO
"cx18: End initialization\n");
1227 static void module_cleanup(void)
1229 pci_unregister_driver(&cx18_pci_driver
);
1232 module_init(module_start
);
1233 module_exit(module_cleanup
);