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@md.metrocast.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 "cx18-controls.h"
40 #include "tuner-xc2028.h"
42 #include <media/tveeprom.h>
44 /* If you have already X v4l cards, then set this to X. This way
45 the device numbers stay matched. Example: you have a WinTV card
46 without radio and a Compro H900 with. Normally this would give a
47 video1 device together with a radio0 device for the Compro. By
48 setting this to 1 you ensure that radio0 is now also radio1. */
51 /* Callback for registering extensions */
52 int (*cx18_ext_init
)(struct cx18
*);
53 EXPORT_SYMBOL(cx18_ext_init
);
55 /* add your revision and whatnot here */
56 static struct pci_device_id cx18_pci_tbl
[] __devinitdata
= {
57 {PCI_VENDOR_ID_CX
, PCI_DEVICE_ID_CX23418
,
58 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
62 MODULE_DEVICE_TABLE(pci
, cx18_pci_tbl
);
64 static atomic_t cx18_instance
= ATOMIC_INIT(0);
66 /* Parameter declarations */
67 static int cardtype
[CX18_MAX_CARDS
];
68 static int tuner
[CX18_MAX_CARDS
] = { -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 -1, -1, -1, -1, -1, -1, -1, -1 };
72 static int radio
[CX18_MAX_CARDS
] = { -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1,
74 -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1 };
76 static unsigned cardtype_c
= 1;
77 static unsigned tuner_c
= 1;
78 static unsigned radio_c
= 1;
79 static char pal
[] = "--";
80 static char secam
[] = "--";
81 static char ntsc
[] = "-";
84 static int enc_ts_buffers
= CX18_DEFAULT_ENC_TS_BUFFERS
;
85 static int enc_mpg_buffers
= CX18_DEFAULT_ENC_MPG_BUFFERS
;
86 static int enc_idx_buffers
= CX18_DEFAULT_ENC_IDX_BUFFERS
;
87 static int enc_yuv_buffers
= CX18_DEFAULT_ENC_YUV_BUFFERS
;
88 static int enc_vbi_buffers
= CX18_DEFAULT_ENC_VBI_BUFFERS
;
89 static int enc_pcm_buffers
= CX18_DEFAULT_ENC_PCM_BUFFERS
;
91 static int enc_ts_bufsize
= CX18_DEFAULT_ENC_TS_BUFSIZE
;
92 static int enc_mpg_bufsize
= CX18_DEFAULT_ENC_MPG_BUFSIZE
;
93 static int enc_idx_bufsize
= CX18_DEFAULT_ENC_IDX_BUFSIZE
;
94 static int enc_yuv_bufsize
= CX18_DEFAULT_ENC_YUV_BUFSIZE
;
95 static int enc_pcm_bufsize
= CX18_DEFAULT_ENC_PCM_BUFSIZE
;
97 static int enc_ts_bufs
= -1;
98 static int enc_mpg_bufs
= -1;
99 static int enc_idx_bufs
= CX18_MAX_FW_MDLS_PER_STREAM
;
100 static int enc_yuv_bufs
= -1;
101 static int enc_vbi_bufs
= -1;
102 static int enc_pcm_bufs
= -1;
105 static int cx18_pci_latency
= 1;
107 static int mmio_ndelay
;
108 static int retry_mmio
= 1;
112 module_param_array(tuner
, int, &tuner_c
, 0644);
113 module_param_array(radio
, bool, &radio_c
, 0644);
114 module_param_array(cardtype
, int, &cardtype_c
, 0644);
115 module_param_string(pal
, pal
, sizeof(pal
), 0644);
116 module_param_string(secam
, secam
, sizeof(secam
), 0644);
117 module_param_string(ntsc
, ntsc
, sizeof(ntsc
), 0644);
118 module_param_named(debug
, cx18_debug
, int, 0644);
119 module_param(mmio_ndelay
, int, 0644);
120 module_param(retry_mmio
, int, 0644);
121 module_param(cx18_pci_latency
, int, 0644);
122 module_param(cx18_first_minor
, int, 0644);
124 module_param(enc_ts_buffers
, int, 0644);
125 module_param(enc_mpg_buffers
, int, 0644);
126 module_param(enc_idx_buffers
, int, 0644);
127 module_param(enc_yuv_buffers
, int, 0644);
128 module_param(enc_vbi_buffers
, int, 0644);
129 module_param(enc_pcm_buffers
, int, 0644);
131 module_param(enc_ts_bufsize
, int, 0644);
132 module_param(enc_mpg_bufsize
, int, 0644);
133 module_param(enc_idx_bufsize
, int, 0644);
134 module_param(enc_yuv_bufsize
, int, 0644);
135 module_param(enc_pcm_bufsize
, int, 0644);
137 module_param(enc_ts_bufs
, int, 0644);
138 module_param(enc_mpg_bufs
, int, 0644);
139 module_param(enc_idx_bufs
, int, 0644);
140 module_param(enc_yuv_bufs
, int, 0644);
141 module_param(enc_vbi_bufs
, int, 0644);
142 module_param(enc_pcm_bufs
, int, 0644);
144 MODULE_PARM_DESC(tuner
, "Tuner type selection,\n"
145 "\t\t\tsee tuner.h for values");
146 MODULE_PARM_DESC(radio
,
147 "Enable or disable the radio. Use only if autodetection\n"
148 "\t\t\tfails. 0 = disable, 1 = enable");
149 MODULE_PARM_DESC(cardtype
,
150 "Only use this option if your card is not detected properly.\n"
151 "\t\tSpecify card type:\n"
152 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
153 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
154 "\t\t\t 3 = Compro VideoMate H900\n"
155 "\t\t\t 4 = Yuan MPC718\n"
156 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
157 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
158 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
159 "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
160 "\t\t\t 9 = GoTView PCI DVD3 Hybrid\n"
161 "\t\t\t 10 = Hauppauge HVR 1600 (S5H1411)\n"
162 "\t\t\t 0 = Autodetect (default)\n"
163 "\t\t\t-1 = Ignore this card\n\t\t");
164 MODULE_PARM_DESC(pal
, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
165 MODULE_PARM_DESC(secam
, "Set SECAM standard: B, G, H, D, K, L, LC");
166 MODULE_PARM_DESC(ntsc
, "Set NTSC standard: M, J, K");
167 MODULE_PARM_DESC(debug
,
168 "Debug level (bitmask). Default: 0\n"
169 "\t\t\t 1/0x0001: warning\n"
170 "\t\t\t 2/0x0002: info\n"
171 "\t\t\t 4/0x0004: mailbox\n"
172 "\t\t\t 8/0x0008: dma\n"
173 "\t\t\t 16/0x0010: ioctl\n"
174 "\t\t\t 32/0x0020: file\n"
175 "\t\t\t 64/0x0040: i2c\n"
176 "\t\t\t128/0x0080: irq\n"
177 "\t\t\t256/0x0100: high volume\n");
178 MODULE_PARM_DESC(cx18_pci_latency
,
179 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
180 "\t\t\tDefault: Yes");
181 MODULE_PARM_DESC(retry_mmio
,
182 "(Deprecated) MMIO writes are now always checked and retried\n"
183 "\t\t\tEffectively: 1 [Yes]");
184 MODULE_PARM_DESC(mmio_ndelay
,
185 "(Deprecated) MMIO accesses are now never purposely delayed\n"
186 "\t\t\tEffectively: 0 ns");
187 MODULE_PARM_DESC(enc_ts_buffers
,
188 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
189 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS
));
190 MODULE_PARM_DESC(enc_ts_bufsize
,
191 "Size of an encoder TS buffer (kB)\n"
192 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE
));
193 MODULE_PARM_DESC(enc_ts_bufs
,
194 "Number of encoder TS buffers\n"
195 "\t\t\tDefault is computed from other enc_ts_* parameters");
196 MODULE_PARM_DESC(enc_mpg_buffers
,
197 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
198 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS
));
199 MODULE_PARM_DESC(enc_mpg_bufsize
,
200 "Size of an encoder MPG buffer (kB)\n"
201 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE
));
202 MODULE_PARM_DESC(enc_mpg_bufs
,
203 "Number of encoder MPG buffers\n"
204 "\t\t\tDefault is computed from other enc_mpg_* parameters");
205 MODULE_PARM_DESC(enc_idx_buffers
,
206 "(Deprecated) Encoder IDX buffer memory (MB)\n"
207 "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
208 "\t\t\tDefault: 1 [Enabled]");
209 MODULE_PARM_DESC(enc_idx_bufsize
,
210 "Size of an encoder IDX buffer (kB)\n"
211 "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
212 "\t\t\t(multiples of size required for 64 index entries)\n"
214 MODULE_PARM_DESC(enc_idx_bufs
,
215 "Number of encoder IDX buffers\n"
216 "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM
));
217 MODULE_PARM_DESC(enc_yuv_buffers
,
218 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
219 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS
));
220 MODULE_PARM_DESC(enc_yuv_bufsize
,
221 "Size of an encoder YUV buffer (kB)\n"
222 "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
223 "\t\t\t(multiples of size required for 32 screen lines)\n"
224 "\t\t\tDefault: 102");
225 MODULE_PARM_DESC(enc_yuv_bufs
,
226 "Number of encoder YUV buffers\n"
227 "\t\t\tDefault is computed from other enc_yuv_* parameters");
228 MODULE_PARM_DESC(enc_vbi_buffers
,
229 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
230 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS
));
231 MODULE_PARM_DESC(enc_vbi_bufs
,
232 "Number of encoder VBI buffers\n"
233 "\t\t\tDefault is computed from enc_vbi_buffers");
234 MODULE_PARM_DESC(enc_pcm_buffers
,
235 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
236 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS
));
237 MODULE_PARM_DESC(enc_pcm_bufsize
,
238 "Size of an encoder PCM buffer (kB)\n"
239 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE
));
240 MODULE_PARM_DESC(enc_pcm_bufs
,
241 "Number of encoder PCM buffers\n"
242 "\t\t\tDefault is computed from other enc_pcm_* parameters");
244 MODULE_PARM_DESC(cx18_first_minor
,
245 "Set device node number assigned to first card");
247 MODULE_AUTHOR("Hans Verkuil");
248 MODULE_DESCRIPTION("CX23418 driver");
249 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
250 MODULE_LICENSE("GPL");
252 MODULE_VERSION(CX18_VERSION
);
254 #if defined(CONFIG_MODULES) && defined(MODULE)
255 static void request_module_async(struct work_struct
*work
)
257 struct cx18
*dev
= container_of(work
, struct cx18
, request_module_wk
);
259 /* Make sure cx18-alsa module is loaded */
260 request_module("cx18-alsa");
262 /* Initialize cx18-alsa for this instance of the cx18 device */
263 if (cx18_ext_init
!= NULL
)
267 static void request_modules(struct cx18
*dev
)
269 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
270 schedule_work(&dev
->request_module_wk
);
273 static void flush_request_modules(struct cx18
*dev
)
275 flush_work_sync(&dev
->request_module_wk
);
278 #define request_modules(dev)
279 #define flush_request_modules(dev)
280 #endif /* CONFIG_MODULES */
282 /* Generic utility functions */
283 int cx18_msleep_timeout(unsigned int msecs
, int intr
)
285 long int timeout
= msecs_to_jiffies(msecs
);
289 set_current_state(intr
? TASK_INTERRUPTIBLE
: TASK_UNINTERRUPTIBLE
);
290 timeout
= schedule_timeout(timeout
);
291 sig
= intr
? signal_pending(current
) : 0;
292 } while (!sig
&& timeout
);
296 /* Release ioremapped memory */
297 static void cx18_iounmap(struct cx18
*cx
)
302 /* Release io memory */
303 if (cx
->enc_mem
!= NULL
) {
304 CX18_DEBUG_INFO("releasing enc_mem\n");
305 iounmap(cx
->enc_mem
);
310 static void cx18_eeprom_dump(struct cx18
*cx
, unsigned char *eedata
, int len
)
314 CX18_INFO("eeprom dump:\n");
315 for (i
= 0; i
< len
; i
++) {
317 CX18_INFO("eeprom %02x:", i
);
318 printk(KERN_CONT
" %02x", eedata
[i
]);
320 printk(KERN_CONT
"\n");
324 /* Hauppauge card? get values from tveeprom */
325 void cx18_read_eeprom(struct cx18
*cx
, struct tveeprom
*tv
)
330 memset(&c
, 0, sizeof(c
));
331 strlcpy(c
.name
, "cx18 tveeprom tmp", sizeof(c
.name
));
332 c
.adapter
= &cx
->i2c_adap
[0];
335 memset(tv
, 0, sizeof(*tv
));
336 if (tveeprom_read(&c
, eedata
, sizeof(eedata
)))
339 switch (cx
->card
->type
) {
340 case CX18_CARD_HVR_1600_ESMT
:
341 case CX18_CARD_HVR_1600_SAMSUNG
:
342 case CX18_CARD_HVR_1600_S5H1411
:
343 tveeprom_hauppauge_analog(&c
, tv
, eedata
);
345 case CX18_CARD_YUAN_MPC718
:
346 case CX18_CARD_GOTVIEW_PCI_DVD3
:
348 cx18_eeprom_dump(cx
, eedata
, sizeof(eedata
));
349 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
350 eedata
[2], eedata
[1], eedata
[4], eedata
[3]);
353 tv
->model
= 0xffffffff;
354 cx18_eeprom_dump(cx
, eedata
, sizeof(eedata
));
359 static void cx18_process_eeprom(struct cx18
*cx
)
363 cx18_read_eeprom(cx
, &tv
);
365 /* Many thanks to Steven Toth from Hauppauge for providing the
367 /* Note: the Samsung memory models cannot be reliably determined
368 from the model number. Use the cardtype module option if you
369 have one of these preproduction models. */
371 case 74301: /* Retail models */
373 case 74351: /* OEM models */
375 /* Digital side is s5h1411/tda18271 */
376 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_S5H1411
);
378 case 74021: /* Retail models */
382 case 74541: /* OEM models */
389 /* Digital side is s5h1409/mxl5005s */
390 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
395 CX18_INFO("Unknown EEPROM encoding\n");
398 CX18_ERR("Invalid EEPROM\n");
401 CX18_ERR("Unknown model %d, defaulting to original HVR-1600 "
402 "(cardtype=1)\n", tv
.model
);
403 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
407 cx
->v4l2_cap
= cx
->card
->v4l2_capabilities
;
408 cx
->card_name
= cx
->card
->name
;
409 cx
->card_i2c
= cx
->card
->i2c
;
411 CX18_INFO("Autodetected %s\n", cx
->card_name
);
413 if (tv
.tuner_type
== TUNER_ABSENT
)
414 CX18_ERR("tveeprom cannot autodetect tuner!\n");
416 if (cx
->options
.tuner
== -1)
417 cx
->options
.tuner
= tv
.tuner_type
;
418 if (cx
->options
.radio
== -1)
419 cx
->options
.radio
= (tv
.has_radio
!= 0);
422 /* user specified tuner standard */
425 /* autodetect tuner standard */
426 if (tv
.tuner_formats
& V4L2_STD_PAL
) {
427 CX18_DEBUG_INFO("PAL tuner detected\n");
428 cx
->std
|= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
429 } else if (tv
.tuner_formats
& V4L2_STD_NTSC
) {
430 CX18_DEBUG_INFO("NTSC tuner detected\n");
431 cx
->std
|= V4L2_STD_NTSC_M
;
432 } else if (tv
.tuner_formats
& V4L2_STD_SECAM
) {
433 CX18_DEBUG_INFO("SECAM tuner detected\n");
434 cx
->std
|= V4L2_STD_SECAM_L
;
436 CX18_INFO("No tuner detected, default to NTSC-M\n");
437 cx
->std
|= V4L2_STD_NTSC_M
;
441 static v4l2_std_id
cx18_parse_std(struct cx18
*cx
)
445 return V4L2_STD_PAL_60
;
450 return V4L2_STD_PAL_BG
;
453 return V4L2_STD_PAL_H
;
456 if (pal
[1] == 'c' || pal
[1] == 'C')
457 return V4L2_STD_PAL_Nc
;
458 return V4L2_STD_PAL_N
;
461 return V4L2_STD_PAL_I
;
466 return V4L2_STD_PAL_DK
;
469 return V4L2_STD_PAL_M
;
473 CX18_WARN("pal= argument not recognised\n");
484 return V4L2_STD_SECAM_B
| V4L2_STD_SECAM_G
| V4L2_STD_SECAM_H
;
489 return V4L2_STD_SECAM_DK
;
492 if (secam
[1] == 'C' || secam
[1] == 'c')
493 return V4L2_STD_SECAM_LC
;
494 return V4L2_STD_SECAM_L
;
498 CX18_WARN("secam= argument not recognised\n");
505 return V4L2_STD_NTSC_M
;
508 return V4L2_STD_NTSC_M_JP
;
511 return V4L2_STD_NTSC_M_KR
;
515 CX18_WARN("ntsc= argument not recognised\n");
523 static void cx18_process_options(struct cx18
*cx
)
527 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_buffers
;
528 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_buffers
;
529 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_buffers
;
530 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_buffers
;
531 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_VBI
] = enc_vbi_buffers
;
532 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_buffers
;
533 cx
->options
.megabytes
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control only */
535 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_bufs
;
536 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_bufs
;
537 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_bufs
;
538 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_bufs
;
539 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_VBI
] = enc_vbi_bufs
;
540 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_bufs
;
541 cx
->stream_buffers
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control, no data */
543 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_TS
] = enc_ts_bufsize
;
544 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_MPG
] = enc_mpg_bufsize
;
545 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_IDX
] = enc_idx_bufsize
;
546 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_YUV
] = enc_yuv_bufsize
;
547 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_VBI
] = vbi_active_samples
* 36;
548 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_PCM
] = enc_pcm_bufsize
;
549 cx
->stream_buf_size
[CX18_ENC_STREAM_TYPE_RAD
] = 0; /* control no data */
551 /* Ensure stream_buffers & stream_buf_size are valid */
552 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++) {
553 if (cx
->stream_buffers
[i
] == 0 || /* User said 0 buffers */
554 cx
->options
.megabytes
[i
] <= 0 || /* User said 0 MB total */
555 cx
->stream_buf_size
[i
] <= 0) { /* User said buf size 0 */
556 cx
->options
.megabytes
[i
] = 0;
557 cx
->stream_buffers
[i
] = 0;
558 cx
->stream_buf_size
[i
] = 0;
562 * YUV is a special case where the stream_buf_size needs to be
563 * an integral multiple of 33.75 kB (storage for 32 screens
564 * lines to maintain alignment in case of lost buffers).
566 * IDX is a special case where the stream_buf_size should be
567 * an integral multiple of 1.5 kB (storage for 64 index entries
568 * to maintain alignment in case of lost buffers).
571 if (i
== CX18_ENC_STREAM_TYPE_YUV
) {
572 cx
->stream_buf_size
[i
] *= 1024;
573 cx
->stream_buf_size
[i
] -=
574 (cx
->stream_buf_size
[i
] % CX18_UNIT_ENC_YUV_BUFSIZE
);
576 if (cx
->stream_buf_size
[i
] < CX18_UNIT_ENC_YUV_BUFSIZE
)
577 cx
->stream_buf_size
[i
] =
578 CX18_UNIT_ENC_YUV_BUFSIZE
;
579 } else if (i
== CX18_ENC_STREAM_TYPE_IDX
) {
580 cx
->stream_buf_size
[i
] *= 1024;
581 cx
->stream_buf_size
[i
] -=
582 (cx
->stream_buf_size
[i
] % CX18_UNIT_ENC_IDX_BUFSIZE
);
584 if (cx
->stream_buf_size
[i
] < CX18_UNIT_ENC_IDX_BUFSIZE
)
585 cx
->stream_buf_size
[i
] =
586 CX18_UNIT_ENC_IDX_BUFSIZE
;
589 * YUV and IDX are special cases where the stream_buf_size is
591 * VBI is a special case where the stream_buf_size is fixed
592 * and already in bytes
594 if (i
== CX18_ENC_STREAM_TYPE_VBI
||
595 i
== CX18_ENC_STREAM_TYPE_YUV
||
596 i
== CX18_ENC_STREAM_TYPE_IDX
) {
597 if (cx
->stream_buffers
[i
] < 0) {
598 cx
->stream_buffers
[i
] =
599 cx
->options
.megabytes
[i
] * 1024 * 1024
600 / cx
->stream_buf_size
[i
];
602 /* N.B. This might round down to 0 */
603 cx
->options
.megabytes
[i
] =
604 cx
->stream_buffers
[i
]
605 * cx
->stream_buf_size
[i
]/(1024 * 1024);
608 /* All other streams have stream_buf_size in kB here */
609 if (cx
->stream_buffers
[i
] < 0) {
610 cx
->stream_buffers
[i
] =
611 cx
->options
.megabytes
[i
] * 1024
612 / cx
->stream_buf_size
[i
];
614 /* N.B. This might round down to 0 */
615 cx
->options
.megabytes
[i
] =
616 cx
->stream_buffers
[i
]
617 * cx
->stream_buf_size
[i
] / 1024;
619 /* convert from kB to bytes */
620 cx
->stream_buf_size
[i
] *= 1024;
622 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
623 "%d bytes\n", i
, cx
->options
.megabytes
[i
],
624 cx
->stream_buffers
[i
], cx
->stream_buf_size
[i
]);
627 cx
->options
.cardtype
= cardtype
[cx
->instance
];
628 cx
->options
.tuner
= tuner
[cx
->instance
];
629 cx
->options
.radio
= radio
[cx
->instance
];
631 cx
->std
= cx18_parse_std(cx
);
632 if (cx
->options
.cardtype
== -1) {
633 CX18_INFO("Ignore card\n");
636 cx
->card
= cx18_get_card(cx
->options
.cardtype
- 1);
638 CX18_INFO("User specified %s card\n", cx
->card
->name
);
639 else if (cx
->options
.cardtype
!= 0)
640 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
641 if (cx
->card
== NULL
) {
642 if (cx
->pci_dev
->subsystem_vendor
== CX18_PCI_ID_HAUPPAUGE
) {
643 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
644 CX18_INFO("Autodetected Hauppauge card\n");
647 if (cx
->card
== NULL
) {
648 for (i
= 0; (cx
->card
= cx18_get_card(i
)); i
++) {
649 if (cx
->card
->pci_list
== NULL
)
651 for (j
= 0; cx
->card
->pci_list
[j
].device
; j
++) {
652 if (cx
->pci_dev
->device
!=
653 cx
->card
->pci_list
[j
].device
)
655 if (cx
->pci_dev
->subsystem_vendor
!=
656 cx
->card
->pci_list
[j
].subsystem_vendor
)
658 if (cx
->pci_dev
->subsystem_device
!=
659 cx
->card
->pci_list
[j
].subsystem_device
)
661 CX18_INFO("Autodetected %s card\n", cx
->card
->name
);
668 if (cx
->card
== NULL
) {
669 cx
->card
= cx18_get_card(CX18_CARD_HVR_1600_ESMT
);
670 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
671 cx
->pci_dev
->vendor
, cx
->pci_dev
->device
);
672 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
673 cx
->pci_dev
->subsystem_vendor
,
674 cx
->pci_dev
->subsystem_device
);
675 CX18_ERR("Defaulting to %s card\n", cx
->card
->name
);
676 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
677 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
678 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
680 cx
->v4l2_cap
= cx
->card
->v4l2_capabilities
;
681 cx
->card_name
= cx
->card
->name
;
682 cx
->card_i2c
= cx
->card
->i2c
;
685 static int __devinit
cx18_create_in_workq(struct cx18
*cx
)
687 snprintf(cx
->in_workq_name
, sizeof(cx
->in_workq_name
), "%s-in",
689 cx
->in_work_queue
= alloc_ordered_workqueue(cx
->in_workq_name
, 0);
690 if (cx
->in_work_queue
== NULL
) {
691 CX18_ERR("Unable to create incoming mailbox handler thread\n");
697 static void __devinit
cx18_init_in_work_orders(struct cx18
*cx
)
700 for (i
= 0; i
< CX18_MAX_IN_WORK_ORDERS
; i
++) {
701 cx
->in_work_order
[i
].cx
= cx
;
702 cx
->in_work_order
[i
].str
= cx
->epu_debug_str
;
703 INIT_WORK(&cx
->in_work_order
[i
].work
, cx18_in_work_handler
);
707 /* Precondition: the cx18 structure has been memset to 0. Only
708 the dev and instance fields have been filled in.
709 No assumptions on the card type may be made here (see cx18_init_struct2
712 static int __devinit
cx18_init_struct1(struct cx18
*cx
)
716 cx
->base_addr
= pci_resource_start(cx
->pci_dev
, 0);
718 mutex_init(&cx
->serialize_lock
);
719 mutex_init(&cx
->gpio_lock
);
720 mutex_init(&cx
->epu2apu_mb_lock
);
721 mutex_init(&cx
->epu2cpu_mb_lock
);
723 ret
= cx18_create_in_workq(cx
);
727 cx18_init_in_work_orders(cx
);
729 /* start counting open_id at 1 */
732 /* Initial settings */
733 cx
->cxhdl
.port
= CX2341X_PORT_MEMORY
;
734 cx
->cxhdl
.capabilities
= CX2341X_CAP_HAS_TS
| CX2341X_CAP_HAS_SLICED_VBI
;
735 cx
->cxhdl
.ops
= &cx18_cxhdl_ops
;
736 cx
->cxhdl
.func
= cx18_api_func
;
737 ret
= cx2341x_handler_init(&cx
->cxhdl
, 50);
740 cx
->v4l2_dev
.ctrl_handler
= &cx
->cxhdl
.hdl
;
742 cx
->temporal_strength
= cx
->cxhdl
.video_temporal_filter
->cur
.val
;
743 cx
->spatial_strength
= cx
->cxhdl
.video_spatial_filter
->cur
.val
;
744 cx
->filter_mode
= cx
->cxhdl
.video_spatial_filter_mode
->cur
.val
|
745 (cx
->cxhdl
.video_temporal_filter_mode
->cur
.val
<< 1) |
746 (cx
->cxhdl
.video_median_filter_type
->cur
.val
<< 2);
748 init_waitqueue_head(&cx
->cap_w
);
749 init_waitqueue_head(&cx
->mb_apu_waitq
);
750 init_waitqueue_head(&cx
->mb_cpu_waitq
);
751 init_waitqueue_head(&cx
->dma_waitq
);
754 cx
->vbi
.in
.type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
755 cx
->vbi
.sliced_in
= &cx
->vbi
.in
.fmt
.sliced
;
757 /* IVTV style VBI insertion into MPEG streams */
758 INIT_LIST_HEAD(&cx
->vbi
.sliced_mpeg_buf
.list
);
759 INIT_LIST_HEAD(&cx
->vbi
.sliced_mpeg_mdl
.list
);
760 INIT_LIST_HEAD(&cx
->vbi
.sliced_mpeg_mdl
.buf_list
);
761 list_add(&cx
->vbi
.sliced_mpeg_buf
.list
,
762 &cx
->vbi
.sliced_mpeg_mdl
.buf_list
);
766 /* Second initialization part. Here the card type has been
768 static void __devinit
cx18_init_struct2(struct cx18
*cx
)
772 for (i
= 0; i
< CX18_CARD_MAX_VIDEO_INPUTS
; i
++)
773 if (cx
->card
->video_inputs
[i
].video_type
== 0)
776 for (i
= 0; i
< CX18_CARD_MAX_AUDIO_INPUTS
; i
++)
777 if (cx
->card
->audio_inputs
[i
].audio_type
== 0)
779 cx
->nof_audio_inputs
= i
;
781 /* Find tuner input */
782 for (i
= 0; i
< cx
->nof_inputs
; i
++) {
783 if (cx
->card
->video_inputs
[i
].video_type
==
784 CX18_CARD_INPUT_VID_TUNER
)
787 if (i
== cx
->nof_inputs
)
789 cx
->active_input
= i
;
790 cx
->audio_input
= cx
->card
->video_inputs
[i
].audio_index
;
793 static int cx18_setup_pci(struct cx18
*cx
, struct pci_dev
*pci_dev
,
794 const struct pci_device_id
*pci_id
)
797 unsigned char pci_latency
;
799 CX18_DEBUG_INFO("Enabling pci device\n");
801 if (pci_enable_device(pci_dev
)) {
802 CX18_ERR("Can't enable device %d!\n", cx
->instance
);
805 if (pci_set_dma_mask(pci_dev
, 0xffffffff)) {
806 CX18_ERR("No suitable DMA available, card %d\n", cx
->instance
);
809 if (!request_mem_region(cx
->base_addr
, CX18_MEM_SIZE
, "cx18 encoder")) {
810 CX18_ERR("Cannot request encoder memory region, card %d\n",
815 /* Enable bus mastering and memory mapped IO for the CX23418 */
816 pci_read_config_word(pci_dev
, PCI_COMMAND
, &cmd
);
817 cmd
|= PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
;
818 pci_write_config_word(pci_dev
, PCI_COMMAND
, cmd
);
820 pci_read_config_byte(pci_dev
, PCI_CLASS_REVISION
, &cx
->card_rev
);
821 pci_read_config_byte(pci_dev
, PCI_LATENCY_TIMER
, &pci_latency
);
823 if (pci_latency
< 64 && cx18_pci_latency
) {
824 CX18_INFO("Unreasonably low latency timer, "
825 "setting to 64 (was %d)\n", pci_latency
);
826 pci_write_config_byte(pci_dev
, PCI_LATENCY_TIMER
, 64);
827 pci_read_config_byte(pci_dev
, PCI_LATENCY_TIMER
, &pci_latency
);
830 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
831 "irq: %d, latency: %d, memory: 0x%lx\n",
832 cx
->pci_dev
->device
, cx
->card_rev
, pci_dev
->bus
->number
,
833 PCI_SLOT(pci_dev
->devfn
), PCI_FUNC(pci_dev
->devfn
),
834 cx
->pci_dev
->irq
, pci_latency
, (unsigned long)cx
->base_addr
);
839 static void cx18_init_subdevs(struct cx18
*cx
)
841 u32 hw
= cx
->card
->hw_all
;
845 for (i
= 0, device
= 1; i
< 32; i
++, device
<<= 1) {
852 case CX18_HW_TVEEPROM
:
853 /* These subordinate devices do not use probing */
854 cx
->hw_flags
|= device
;
857 /* The A/V decoder gets probed earlier to set PLLs */
858 /* Just note that the card uses it (i.e. has analog) */
859 cx
->hw_flags
|= device
;
861 case CX18_HW_GPIO_RESET_CTRL
:
863 * The Reset Controller gets probed and added to
864 * hw_flags earlier for i2c adapter/bus initialization
867 case CX18_HW_GPIO_MUX
:
868 if (cx18_gpio_register(cx
, device
) == 0)
869 cx
->hw_flags
|= device
;
872 if (cx18_i2c_register(cx
, i
) == 0)
873 cx
->hw_flags
|= device
;
878 if (cx
->hw_flags
& CX18_HW_418_AV
)
879 cx
->sd_av
= cx18_find_hw(cx
, CX18_HW_418_AV
);
881 if (cx
->card
->hw_muxer
!= 0)
882 cx
->sd_extmux
= cx18_find_hw(cx
, cx
->card
->hw_muxer
);
885 static int __devinit
cx18_probe(struct pci_dev
*pci_dev
,
886 const struct pci_device_id
*pci_id
)
893 /* FIXME - module parameter arrays constrain max instances */
894 i
= atomic_inc_return(&cx18_instance
) - 1;
895 if (i
>= CX18_MAX_CARDS
) {
896 printk(KERN_ERR
"cx18: cannot manage card %d, driver has a "
897 "limit of 0 - %d\n", i
, CX18_MAX_CARDS
- 1);
901 cx
= kzalloc(sizeof(struct cx18
), GFP_ATOMIC
);
903 printk(KERN_ERR
"cx18: cannot manage card %d, out of memory\n",
907 cx
->pci_dev
= pci_dev
;
910 retval
= v4l2_device_register(&pci_dev
->dev
, &cx
->v4l2_dev
);
912 printk(KERN_ERR
"cx18: v4l2_device_register of card %d failed"
917 snprintf(cx
->v4l2_dev
.name
, sizeof(cx
->v4l2_dev
.name
), "cx18-%d",
919 CX18_INFO("Initializing card %d\n", cx
->instance
);
921 cx18_process_options(cx
);
922 if (cx
->options
.cardtype
== -1) {
927 retval
= cx18_init_struct1(cx
);
931 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx
->base_addr
);
933 /* PCI Device Setup */
934 retval
= cx18_setup_pci(cx
, pci_dev
, pci_id
);
936 goto free_workqueues
;
939 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
940 cx
->base_addr
+ CX18_MEM_OFFSET
, CX18_MEM_SIZE
);
941 cx
->enc_mem
= ioremap_nocache(cx
->base_addr
+ CX18_MEM_OFFSET
,
944 CX18_ERR("ioremap failed. Can't get a window into CX23418 "
945 "memory and register space\n");
946 CX18_ERR("Each capture card with a CX23418 needs 64 MB of "
947 "vmalloc address space for the window\n");
948 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
949 CX18_ERR("Use the vmalloc= kernel command line option to set "
950 "VmallocTotal to a larger value\n");
954 cx
->reg_mem
= cx
->enc_mem
+ CX18_REG_OFFSET
;
955 devtype
= cx18_read_reg(cx
, 0xC72028);
956 switch (devtype
& 0xff000000) {
958 CX18_INFO("cx23418 revision %08x (A)\n", devtype
);
961 CX18_INFO("cx23418 revision %08x (B)\n", devtype
);
964 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype
);
968 cx18_init_power(cx
, 1);
969 cx18_init_memory(cx
);
971 cx
->scb
= (struct cx18_scb __iomem
*)(cx
->enc_mem
+ SCB_OFFSET
);
976 /* Initialize integrated A/V decoder early to set PLLs, just in case */
977 retval
= cx18_av_probe(cx
);
979 CX18_ERR("Could not register A/V decoder subdevice\n");
983 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
984 if (cx
->card
->hw_all
& CX18_HW_GPIO_RESET_CTRL
) {
985 if (cx18_gpio_register(cx
, CX18_HW_GPIO_RESET_CTRL
) != 0)
986 CX18_WARN("Could not register GPIO reset controller"
987 "subdevice; proceeding anyway.\n");
989 cx
->hw_flags
|= CX18_HW_GPIO_RESET_CTRL
;
993 CX18_DEBUG_INFO("activating i2c...\n");
994 retval
= init_cx18_i2c(cx
);
996 CX18_ERR("Could not initialize i2c\n");
1000 if (cx
->card
->hw_all
& CX18_HW_TVEEPROM
) {
1001 /* Based on the model number the cardtype may be changed.
1002 The PCI IDs are not always reliable. */
1003 cx18_process_eeprom(cx
);
1005 if (cx
->card
->comment
)
1006 CX18_INFO("%s", cx
->card
->comment
);
1007 if (cx
->card
->v4l2_capabilities
== 0) {
1011 cx18_init_memory(cx
);
1015 retval
= request_irq(cx
->pci_dev
->irq
, cx18_irq_handler
,
1016 IRQF_SHARED
| IRQF_DISABLED
,
1017 cx
->v4l2_dev
.name
, (void *)cx
);
1019 CX18_ERR("Failed to register irq %d\n", retval
);
1024 cx
->std
= V4L2_STD_NTSC_M
;
1026 if (cx
->options
.tuner
== -1) {
1027 for (i
= 0; i
< CX18_CARD_MAX_TUNERS
; i
++) {
1028 if ((cx
->std
& cx
->card
->tuners
[i
].std
) == 0)
1030 cx
->options
.tuner
= cx
->card
->tuners
[i
].tuner
;
1034 /* if no tuner was found, then pick the first tuner in the card list */
1035 if (cx
->options
.tuner
== -1 && cx
->card
->tuners
[0].std
) {
1036 cx
->std
= cx
->card
->tuners
[0].std
;
1037 if (cx
->std
& V4L2_STD_PAL
)
1038 cx
->std
= V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
;
1039 else if (cx
->std
& V4L2_STD_NTSC
)
1040 cx
->std
= V4L2_STD_NTSC_M
;
1041 else if (cx
->std
& V4L2_STD_SECAM
)
1042 cx
->std
= V4L2_STD_SECAM_L
;
1043 cx
->options
.tuner
= cx
->card
->tuners
[0].tuner
;
1045 if (cx
->options
.radio
== -1)
1046 cx
->options
.radio
= (cx
->card
->radio_input
.audio_type
!= 0);
1048 /* The card is now fully identified, continue with card-specific
1050 cx18_init_struct2(cx
);
1052 cx18_init_subdevs(cx
);
1054 if (cx
->std
& V4L2_STD_525_60
)
1059 cx2341x_handler_set_50hz(&cx
->cxhdl
, !cx
->is_60hz
);
1061 if (cx
->options
.radio
> 0)
1062 cx
->v4l2_cap
|= V4L2_CAP_RADIO
;
1064 if (cx
->options
.tuner
> -1) {
1065 struct tuner_setup setup
;
1067 setup
.addr
= ADDR_UNSET
;
1068 setup
.type
= cx
->options
.tuner
;
1069 setup
.mode_mask
= T_ANALOG_TV
; /* matches TV tuners */
1070 setup
.tuner_callback
= (setup
.type
== TUNER_XC2028
) ?
1071 cx18_reset_tuner_gpio
: NULL
;
1072 cx18_call_all(cx
, tuner
, s_type_addr
, &setup
);
1073 if (setup
.type
== TUNER_XC2028
) {
1074 static struct xc2028_ctrl ctrl
= {
1075 .fname
= XC2028_DEFAULT_FIRMWARE
,
1078 struct v4l2_priv_tun_config cfg
= {
1079 .tuner
= cx
->options
.tuner
,
1082 cx18_call_all(cx
, tuner
, s_config
, &cfg
);
1086 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1088 cx
->tuner_std
= cx
->std
;
1090 retval
= cx18_streams_setup(cx
);
1092 CX18_ERR("Error %d setting up streams\n", retval
);
1095 retval
= cx18_streams_register(cx
);
1097 CX18_ERR("Error %d registering devices\n", retval
);
1101 CX18_INFO("Initialized card: %s\n", cx
->card_name
);
1103 /* Load cx18 submodules (cx18-alsa) */
1104 request_modules(cx
);
1108 cx18_streams_cleanup(cx
, 1);
1110 free_irq(cx
->pci_dev
->irq
, (void *)cx
);
1116 release_mem_region(cx
->base_addr
, CX18_MEM_SIZE
);
1118 destroy_workqueue(cx
->in_work_queue
);
1122 CX18_ERR("Error %d on initialization\n", retval
);
1124 v4l2_device_unregister(&cx
->v4l2_dev
);
1129 int cx18_init_on_first_open(struct cx18
*cx
)
1132 int fw_retry_count
= 3;
1133 struct v4l2_frequency vf
;
1134 struct cx18_open_id fh
;
1138 if (test_bit(CX18_F_I_FAILED
, &cx
->i_flags
))
1141 if (test_and_set_bit(CX18_F_I_INITED
, &cx
->i_flags
))
1144 while (--fw_retry_count
> 0) {
1146 if (cx18_firmware_init(cx
) == 0)
1148 if (fw_retry_count
> 1)
1149 CX18_WARN("Retry loading firmware\n");
1152 if (fw_retry_count
== 0) {
1153 set_bit(CX18_F_I_FAILED
, &cx
->i_flags
);
1156 set_bit(CX18_F_I_LOADED_FW
, &cx
->i_flags
);
1159 * Init the firmware twice to work around a silicon bug
1160 * with the digital TS.
1162 * The second firmware load requires us to normalize the APU state,
1163 * or the audio for the first analog capture will be badly incorrect.
1165 * I can't seem to call APU_RESETAI and have it succeed without the
1166 * APU capturing audio, so we start and stop it here to do the reset
1169 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1170 cx18_vapi(cx
, CX18_APU_START
, 2, CX18_APU_ENCODING_METHOD_MPEG
|0xb9, 0);
1171 cx18_vapi(cx
, CX18_APU_RESETAI
, 0);
1172 cx18_vapi(cx
, CX18_APU_STOP
, 1, CX18_APU_ENCODING_METHOD_MPEG
);
1175 while (--fw_retry_count
> 0) {
1177 if (cx18_firmware_init(cx
) == 0)
1179 if (fw_retry_count
> 1)
1180 CX18_WARN("Retry loading firmware\n");
1183 if (fw_retry_count
== 0) {
1184 set_bit(CX18_F_I_FAILED
, &cx
->i_flags
);
1189 * The second firmware load requires us to normalize the APU state,
1190 * or the audio for the first analog capture will be badly incorrect.
1192 * I can't seem to call APU_RESETAI and have it succeed without the
1193 * APU capturing audio, so we start and stop it here to do the reset
1196 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1197 cx18_vapi(cx
, CX18_APU_START
, 2, CX18_APU_ENCODING_METHOD_MPEG
|0xb9, 0);
1198 cx18_vapi(cx
, CX18_APU_RESETAI
, 0);
1199 cx18_vapi(cx
, CX18_APU_STOP
, 1, CX18_APU_ENCODING_METHOD_MPEG
);
1201 /* Init the A/V decoder, if it hasn't been already */
1202 v4l2_subdev_call(cx
->sd_av
, core
, load_fw
);
1205 vf
.type
= V4L2_TUNER_ANALOG_TV
;
1206 vf
.frequency
= 6400; /* the tuner 'baseline' frequency */
1208 /* Set initial frequency. For PAL/SECAM broadcasts no
1209 'default' channel exists AFAIK. */
1210 if (cx
->std
== V4L2_STD_NTSC_M_JP
)
1211 vf
.frequency
= 1460; /* ch. 1 91250*16/1000 */
1212 else if (cx
->std
& V4L2_STD_NTSC_M
)
1213 vf
.frequency
= 1076; /* ch. 4 67250*16/1000 */
1215 video_input
= cx
->active_input
;
1216 cx
->active_input
++; /* Force update of input */
1217 cx18_s_input(NULL
, &fh
, video_input
);
1219 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1221 cx
->std
++; /* Force full standard initialization */
1222 cx18_s_std(NULL
, &fh
, &cx
->tuner_std
);
1223 cx18_s_frequency(NULL
, &fh
, &vf
);
1227 static void cx18_cancel_in_work_orders(struct cx18
*cx
)
1230 for (i
= 0; i
< CX18_MAX_IN_WORK_ORDERS
; i
++)
1231 cancel_work_sync(&cx
->in_work_order
[i
].work
);
1234 static void cx18_cancel_out_work_orders(struct cx18
*cx
)
1237 for (i
= 0; i
< CX18_MAX_STREAMS
; i
++)
1238 if (&cx
->streams
[i
].video_dev
!= NULL
)
1239 cancel_work_sync(&cx
->streams
[i
].out_work_order
);
1242 static void cx18_remove(struct pci_dev
*pci_dev
)
1244 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pci_dev
);
1245 struct cx18
*cx
= to_cx18(v4l2_dev
);
1248 CX18_DEBUG_INFO("Removing Card\n");
1250 flush_request_modules(cx
);
1252 /* Stop all captures */
1253 CX18_DEBUG_INFO("Stopping all streams\n");
1254 if (atomic_read(&cx
->tot_capturing
) > 0)
1255 cx18_stop_all_captures(cx
);
1257 /* Stop interrupts that cause incoming work to be queued */
1258 cx18_sw1_irq_disable(cx
, IRQ_CPU_TO_EPU
| IRQ_APU_TO_EPU
);
1260 /* Incoming work can cause outgoing work, so clean up incoming first */
1261 cx18_cancel_in_work_orders(cx
);
1262 cx18_cancel_out_work_orders(cx
);
1264 /* Stop ack interrupts that may have been needed for work to finish */
1265 cx18_sw2_irq_disable(cx
, IRQ_CPU_TO_EPU_ACK
| IRQ_APU_TO_EPU_ACK
);
1267 cx18_halt_firmware(cx
);
1269 destroy_workqueue(cx
->in_work_queue
);
1271 cx18_streams_cleanup(cx
, 1);
1275 free_irq(cx
->pci_dev
->irq
, (void *)cx
);
1279 release_mem_region(cx
->base_addr
, CX18_MEM_SIZE
);
1281 pci_disable_device(cx
->pci_dev
);
1283 if (cx
->vbi
.sliced_mpeg_data
[0] != NULL
)
1284 for (i
= 0; i
< CX18_VBI_FRAMES
; i
++)
1285 kfree(cx
->vbi
.sliced_mpeg_data
[i
]);
1287 v4l2_ctrl_handler_free(&cx
->av_state
.hdl
);
1289 CX18_INFO("Removed %s\n", cx
->card_name
);
1291 v4l2_device_unregister(v4l2_dev
);
1296 /* define a pci_driver for card detection */
1297 static struct pci_driver cx18_pci_driver
= {
1299 .id_table
= cx18_pci_tbl
,
1300 .probe
= cx18_probe
,
1301 .remove
= cx18_remove
,
1304 static int __init
module_start(void)
1306 printk(KERN_INFO
"cx18: Start initialization, version %s\n",
1309 /* Validate parameters */
1310 if (cx18_first_minor
< 0 || cx18_first_minor
>= CX18_MAX_CARDS
) {
1311 printk(KERN_ERR
"cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1312 CX18_MAX_CARDS
- 1);
1316 if (cx18_debug
< 0 || cx18_debug
> 511) {
1318 printk(KERN_INFO
"cx18: Debug value must be >= 0 and <= 511!\n");
1321 if (pci_register_driver(&cx18_pci_driver
)) {
1322 printk(KERN_ERR
"cx18: Error detecting PCI card\n");
1325 printk(KERN_INFO
"cx18: End initialization\n");
1329 static void __exit
module_cleanup(void)
1331 pci_unregister_driver(&cx18_pci_driver
);
1334 module_init(module_start
);
1335 module_exit(module_cleanup
);