?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (10283): cx18: Call request_module() with proper argument types.
[linux-2.6.git] / drivers / media / video / cx18 / cx18-driver.c
blob1d3a865b9c6da533dfeca9a67861426269aaf648
1 /*
2 * cx18 driver initialization and card probing
3 *
4 * Derived from ivtv-driver.c
5 *
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
8 *
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.
13 *
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.
18 *
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
22 * 02111-1307 USA
23 */
24
25 #include "cx18-driver.h"
26 #include "cx18-io.h"
27 #include "cx18-version.h"
28 #include "cx18-cards.h"
29 #include "cx18-i2c.h"
30 #include "cx18-irq.h"
31 #include "cx18-gpio.h"
32 #include "cx18-firmware.h"
33 #include "cx18-streams.h"
34 #include "cx18-av-core.h"
35 #include "cx18-scb.h"
36 #include "cx18-mailbox.h"
37 #include "cx18-ioctl.h"
38 #include "tuner-xc2028.h"
39
40 #include <media/tveeprom.h>
41
42
43 /* var to keep track of the number of array elements in use */
44 int cx18_cards_active;
45
46 /* If you have already X v4l cards, then set this to X. This way
47 the device numbers stay matched. Example: you have a WinTV card
48 without radio and a Compro H900 with. Normally this would give a
49 video1 device together with a radio0 device for the Compro. By
50 setting this to 1 you ensure that radio0 is now also radio1. */
51 int cx18_first_minor;
52
53 /* Master variable for all cx18 info */
54 struct cx18 *cx18_cards[CX18_MAX_CARDS];
55
56 /* Protects cx18_cards_active */
57 DEFINE_SPINLOCK(cx18_cards_lock);
58
59 /* add your revision and whatnot here */
60 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
61 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
62 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
63 {0,}
64 };
65
66 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
67
68 /* Parameter declarations */
69 static int cardtype[CX18_MAX_CARDS];
70 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
71 -1, -1, -1, -1, -1, -1, -1, -1,
72 -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1 };
74 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1,
76 -1, -1, -1, -1, -1, -1, -1, -1,
77 -1, -1, -1, -1, -1, -1, -1, -1 };
78 static unsigned cardtype_c = 1;
79 static unsigned tuner_c = 1;
80 static unsigned radio_c = 1;
81 static char pal[] = "--";
82 static char secam[] = "--";
83 static char ntsc[] = "-";
84
85 /* Buffers */
86 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
87 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
88 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
89 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
90 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
91 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
92
93 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
94 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
95 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
96 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
97 /* VBI bufsize based on standards supported by card tuner for now */
98 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
99
100 static int enc_ts_bufs = -1;
101 static int enc_mpg_bufs = -1;
102 static int enc_idx_bufs = -1;
103 static int enc_yuv_bufs = -1;
104 static int enc_vbi_bufs = -1;
105 static int enc_pcm_bufs = -1;
106
107
108 static int cx18_pci_latency = 1;
109
110 static int mmio_ndelay;
111 static int retry_mmio = 1;
112
113 int cx18_debug;
114
115 module_param_array(tuner, int, &tuner_c, 0644);
116 module_param_array(radio, bool, &radio_c, 0644);
117 module_param_array(cardtype, int, &cardtype_c, 0644);
118 module_param_string(pal, pal, sizeof(pal), 0644);
119 module_param_string(secam, secam, sizeof(secam), 0644);
120 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
121 module_param_named(debug, cx18_debug, int, 0644);
122 module_param(mmio_ndelay, int, 0644);
123 module_param(retry_mmio, int, 0644);
124 module_param(cx18_pci_latency, int, 0644);
125 module_param(cx18_first_minor, int, 0644);
126
127 module_param(enc_ts_buffers, int, 0644);
128 module_param(enc_mpg_buffers, int, 0644);
129 module_param(enc_idx_buffers, int, 0644);
130 module_param(enc_yuv_buffers, int, 0644);
131 module_param(enc_vbi_buffers, int, 0644);
132 module_param(enc_pcm_buffers, int, 0644);
133
134 module_param(enc_ts_bufsize, int, 0644);
135 module_param(enc_mpg_bufsize, int, 0644);
136 module_param(enc_idx_bufsize, int, 0644);
137 module_param(enc_yuv_bufsize, int, 0644);
138 /* VBI bufsize based on standards supported by card tuner for now */
139 module_param(enc_pcm_bufsize, int, 0644);
140
141 module_param(enc_ts_bufs, int, 0644);
142 module_param(enc_mpg_bufs, int, 0644);
143 module_param(enc_idx_bufs, int, 0644);
144 module_param(enc_yuv_bufs, int, 0644);
145 module_param(enc_vbi_bufs, int, 0644);
146 module_param(enc_pcm_bufs, int, 0644);
147
148 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
149 "\t\t\tsee tuner.h for values");
150 MODULE_PARM_DESC(radio,
151 "Enable or disable the radio. Use only if autodetection\n"
152 "\t\t\tfails. 0 = disable, 1 = enable");
153 MODULE_PARM_DESC(cardtype,
154 "Only use this option if your card is not detected properly.\n"
155 "\t\tSpecify card type:\n"
156 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
157 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
158 "\t\t\t 3 = Compro VideoMate H900\n"
159 "\t\t\t 4 = Yuan MPC718\n"
160 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
161 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
162 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
163 "\t\t\t 0 = Autodetect (default)\n"
164 "\t\t\t-1 = Ignore this card\n\t\t");
165 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
166 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
167 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
168 MODULE_PARM_DESC(debug,
169 "Debug level (bitmask). Default: 0\n"
170 "\t\t\t 1/0x0001: warning\n"
171 "\t\t\t 2/0x0002: info\n"
172 "\t\t\t 4/0x0004: mailbox\n"
173 "\t\t\t 8/0x0008: dma\n"
174 "\t\t\t 16/0x0010: ioctl\n"
175 "\t\t\t 32/0x0020: file\n"
176 "\t\t\t 64/0x0040: i2c\n"
177 "\t\t\t128/0x0080: irq\n"
178 "\t\t\t256/0x0100: high volume\n");
179 MODULE_PARM_DESC(cx18_pci_latency,
180 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
181 "\t\t\tDefault: Yes");
182 MODULE_PARM_DESC(retry_mmio,
183 "(Deprecated) MMIO writes are now always checked and retried\n"
184 "\t\t\tEffectively: 1 [Yes]");
185 MODULE_PARM_DESC(mmio_ndelay,
186 "(Deprecated) MMIO accesses are now never purposely delayed\n"
187 "\t\t\tEffectively: 0 ns");
188 MODULE_PARM_DESC(enc_ts_buffers,
189 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
190 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
191 MODULE_PARM_DESC(enc_ts_bufsize,
192 "Size of an encoder TS buffer (kB)\n"
193 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
194 MODULE_PARM_DESC(enc_ts_bufs,
195 "Number of encoder TS buffers\n"
196 "\t\t\tDefault is computed from other enc_ts_* parameters");
197 MODULE_PARM_DESC(enc_mpg_buffers,
198 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
199 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
200 MODULE_PARM_DESC(enc_mpg_bufsize,
201 "Size of an encoder MPG buffer (kB)\n"
202 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
203 MODULE_PARM_DESC(enc_mpg_bufs,
204 "Number of encoder MPG buffers\n"
205 "\t\t\tDefault is computed from other enc_mpg_* parameters");
206 MODULE_PARM_DESC(enc_idx_buffers,
207 "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
208 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS));
209 MODULE_PARM_DESC(enc_idx_bufsize,
210 "Size of an encoder IDX buffer (kB)\n"
211 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
212 MODULE_PARM_DESC(enc_idx_bufs,
213 "Number of encoder IDX buffers\n"
214 "\t\t\tDefault is computed from other enc_idx_* parameters");
215 MODULE_PARM_DESC(enc_yuv_buffers,
216 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
217 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
218 MODULE_PARM_DESC(enc_yuv_bufsize,
219 "Size of an encoder YUV buffer (kB)\n"
220 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFSIZE));
221 MODULE_PARM_DESC(enc_yuv_bufs,
222 "Number of encoder YUV buffers\n"
223 "\t\t\tDefault is computed from other enc_yuv_* parameters");
224 MODULE_PARM_DESC(enc_vbi_buffers,
225 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
226 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
227 MODULE_PARM_DESC(enc_vbi_bufs,
228 "Number of encoder VBI buffers\n"
229 "\t\t\tDefault is computed from enc_vbi_buffers & tuner std");
230 MODULE_PARM_DESC(enc_pcm_buffers,
231 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
232 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
233 MODULE_PARM_DESC(enc_pcm_bufsize,
234 "Size of an encoder PCM buffer (kB)\n"
235 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
236 MODULE_PARM_DESC(enc_pcm_bufs,
237 "Number of encoder PCM buffers\n"
238 "\t\t\tDefault is computed from other enc_pcm_* parameters");
239
240 MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
241
242 MODULE_AUTHOR("Hans Verkuil");
243 MODULE_DESCRIPTION("CX23418 driver");
244 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
245 MODULE_LICENSE("GPL");
246
247 MODULE_VERSION(CX18_VERSION);
248
249 /* Generic utility functions */
250 int cx18_msleep_timeout(unsigned int msecs, int intr)
251 {
252 long int timeout = msecs_to_jiffies(msecs);
253 int sig;
254
255 do {
256 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
257 timeout = schedule_timeout(timeout);
258 sig = intr ? signal_pending(current) : 0;
259 } while (!sig && timeout);
260 return sig;
261 }
262
263 /* Release ioremapped memory */
264 static void cx18_iounmap(struct cx18 *cx)
265 {
266 if (cx == NULL)
267 return;
268
269 /* Release io memory */
270 if (cx->enc_mem != NULL) {
271 CX18_DEBUG_INFO("releasing enc_mem\n");
272 iounmap(cx->enc_mem);
273 cx->enc_mem = NULL;
274 }
275 }
276
277 /* Hauppauge card? get values from tveeprom */
278 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
279 {
280 u8 eedata[256];
281
282 cx->i2c_client[0].addr = 0xA0 >> 1;
283 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
284 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
285 }
286
287 static void cx18_process_eeprom(struct cx18 *cx)
288 {
289 struct tveeprom tv;
290
291 cx18_read_eeprom(cx, &tv);
292
293 /* Many thanks to Steven Toth from Hauppauge for providing the
294 model numbers */
295 /* Note: the Samsung memory models cannot be reliably determined
296 from the model number. Use the cardtype module option if you
297 have one of these preproduction models. */
298 switch (tv.model) {
299 case 74000 ... 74999:
300 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
301 break;
302 case 0:
303 CX18_ERR("Invalid EEPROM\n");
304 return;
305 default:
306 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
307 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
308 break;
309 }
310
311 cx->v4l2_cap = cx->card->v4l2_capabilities;
312 cx->card_name = cx->card->name;
313 cx->card_i2c = cx->card->i2c;
314
315 CX18_INFO("Autodetected %s\n", cx->card_name);
316
317 if (tv.tuner_type == TUNER_ABSENT)
318 CX18_ERR("tveeprom cannot autodetect tuner!");
319
320 if (cx->options.tuner == -1)
321 cx->options.tuner = tv.tuner_type;
322 if (cx->options.radio == -1)
323 cx->options.radio = (tv.has_radio != 0);
324
325 if (cx->std != 0)
326 /* user specified tuner standard */
327 return;
328
329 /* autodetect tuner standard */
330 if (tv.tuner_formats & V4L2_STD_PAL) {
331 CX18_DEBUG_INFO("PAL tuner detected\n");
332 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
333 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
334 CX18_DEBUG_INFO("NTSC tuner detected\n");
335 cx->std |= V4L2_STD_NTSC_M;
336 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
337 CX18_DEBUG_INFO("SECAM tuner detected\n");
338 cx->std |= V4L2_STD_SECAM_L;
339 } else {
340 CX18_INFO("No tuner detected, default to NTSC-M\n");
341 cx->std |= V4L2_STD_NTSC_M;
342 }
343 }
344
345 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
346 {
347 switch (pal[0]) {
348 case '6':
349 return V4L2_STD_PAL_60;
350 case 'b':
351 case 'B':
352 case 'g':
353 case 'G':
354 return V4L2_STD_PAL_BG;
355 case 'h':
356 case 'H':
357 return V4L2_STD_PAL_H;
358 case 'n':
359 case 'N':
360 if (pal[1] == 'c' || pal[1] == 'C')
361 return V4L2_STD_PAL_Nc;
362 return V4L2_STD_PAL_N;
363 case 'i':
364 case 'I':
365 return V4L2_STD_PAL_I;
366 case 'd':
367 case 'D':
368 case 'k':
369 case 'K':
370 return V4L2_STD_PAL_DK;
371 case 'M':
372 case 'm':
373 return V4L2_STD_PAL_M;
374 case '-':
375 break;
376 default:
377 CX18_WARN("pal= argument not recognised\n");
378 return 0;
379 }
380
381 switch (secam[0]) {
382 case 'b':
383 case 'B':
384 case 'g':
385 case 'G':
386 case 'h':
387 case 'H':
388 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
389 case 'd':
390 case 'D':
391 case 'k':
392 case 'K':
393 return V4L2_STD_SECAM_DK;
394 case 'l':
395 case 'L':
396 if (secam[1] == 'C' || secam[1] == 'c')
397 return V4L2_STD_SECAM_LC;
398 return V4L2_STD_SECAM_L;
399 case '-':
400 break;
401 default:
402 CX18_WARN("secam= argument not recognised\n");
403 return 0;
404 }
405
406 switch (ntsc[0]) {
407 case 'm':
408 case 'M':
409 return V4L2_STD_NTSC_M;
410 case 'j':
411 case 'J':
412 return V4L2_STD_NTSC_M_JP;
413 case 'k':
414 case 'K':
415 return V4L2_STD_NTSC_M_KR;
416 case '-':
417 break;
418 default:
419 CX18_WARN("ntsc= argument not recognised\n");
420 return 0;
421 }
422
423 /* no match found */
424 return 0;
425 }
426
427 static void cx18_process_options(struct cx18 *cx)
428 {
429 int i, j;
430
431 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
432 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
433 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
434 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
435 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
436 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
437 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
438
439 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
440 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
441 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
442 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
443 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
444 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
445 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
446
447 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
448 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
449 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
450 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
451 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = 0; /* computed later */
452 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
453 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
454
455 /* Except for VBI ensure stream_buffers & stream_buf_size are valid */
456 for (i = 0; i < CX18_MAX_STREAMS; i++) {
457 /* User said to use 0 buffers */
458 if (cx->stream_buffers[i] == 0) {
459 cx->options.megabytes[i] = 0;
460 cx->stream_buf_size[i] = 0;
461 continue;
462 }
463 /* User said to use 0 MB total */
464 if (cx->options.megabytes[i] <= 0) {
465 cx->options.megabytes[i] = 0;
466 cx->stream_buffers[i] = 0;
467 cx->stream_buf_size[i] = 0;
468 continue;
469 }
470 /* VBI is computed later or user said buffer has size 0 */
471 if (cx->stream_buf_size[i] <= 0) {
472 if (i != CX18_ENC_STREAM_TYPE_VBI) {
473 cx->options.megabytes[i] = 0;
474 cx->stream_buffers[i] = 0;
475 cx->stream_buf_size[i] = 0;
476 }
477 continue;
478 }
479 if (cx->stream_buffers[i] < 0) {
480 cx->stream_buffers[i] = cx->options.megabytes[i] * 1024
481 / cx->stream_buf_size[i];
482 } else {
483 /* N.B. This might round down to 0 */
484 cx->options.megabytes[i] =
485 cx->stream_buffers[i] * cx->stream_buf_size[i] / 1024;
486 }
487 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
488 }
489
490 cx->options.cardtype = cardtype[cx->num];
491 cx->options.tuner = tuner[cx->num];
492 cx->options.radio = radio[cx->num];
493
494 cx->std = cx18_parse_std(cx);
495 if (cx->options.cardtype == -1) {
496 CX18_INFO("Ignore card\n");
497 return;
498 }
499 cx->card = cx18_get_card(cx->options.cardtype - 1);
500 if (cx->card)
501 CX18_INFO("User specified %s card\n", cx->card->name);
502 else if (cx->options.cardtype != 0)
503 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
504 if (cx->card == NULL) {
505 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
506 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
507 CX18_INFO("Autodetected Hauppauge card\n");
508 }
509 }
510 if (cx->card == NULL) {
511 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
512 if (cx->card->pci_list == NULL)
513 continue;
514 for (j = 0; cx->card->pci_list[j].device; j++) {
515 if (cx->pci_dev->device !=
516 cx->card->pci_list[j].device)
517 continue;
518 if (cx->pci_dev->subsystem_vendor !=
519 cx->card->pci_list[j].subsystem_vendor)
520 continue;
521 if (cx->pci_dev->subsystem_device !=
522 cx->card->pci_list[j].subsystem_device)
523 continue;
524 CX18_INFO("Autodetected %s card\n", cx->card->name);
525 goto done;
526 }
527 }
528 }
529 done:
530
531 if (cx->card == NULL) {
532 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
533 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
534 cx->pci_dev->vendor, cx->pci_dev->device);
535 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
536 cx->pci_dev->subsystem_vendor,
537 cx->pci_dev->subsystem_device);
538 CX18_ERR("Defaulting to %s card\n", cx->card->name);
539 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
540 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
541 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
542 }
543 cx->v4l2_cap = cx->card->v4l2_capabilities;
544 cx->card_name = cx->card->name;
545 cx->card_i2c = cx->card->i2c;
546 }
547
548 /* Precondition: the cx18 structure has been memset to 0. Only
549 the dev and num fields have been filled in.
550 No assumptions on the card type may be made here (see cx18_init_struct2
551 for that).
552 */
553 static int __devinit cx18_init_struct1(struct cx18 *cx)
554 {
555 int i;
556
557 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
558
559 mutex_init(&cx->serialize_lock);
560 mutex_init(&cx->i2c_bus_lock[0]);
561 mutex_init(&cx->i2c_bus_lock[1]);
562 mutex_init(&cx->gpio_lock);
563 mutex_init(&cx->epu2apu_mb_lock);
564 mutex_init(&cx->epu2cpu_mb_lock);
565
566 spin_lock_init(&cx->lock);
567
568 cx->work_queue = create_singlethread_workqueue(cx->name);
569 if (cx->work_queue == NULL) {
570 CX18_ERR("Unable to create work hander thread\n");
571 return -ENOMEM;
572 }
573
574 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++) {
575 cx->epu_work_order[i].cx = cx;
576 cx->epu_work_order[i].str = cx->epu_debug_str;
577 INIT_WORK(&cx->epu_work_order[i].work, cx18_epu_work_handler);
578 }
579
580 /* start counting open_id at 1 */
581 cx->open_id = 1;
582
583 /* Initial settings */
584 cx2341x_fill_defaults(&cx->params);
585 cx->temporal_strength = cx->params.video_temporal_filter;
586 cx->spatial_strength = cx->params.video_spatial_filter;
587 cx->filter_mode = cx->params.video_spatial_filter_mode |
588 (cx->params.video_temporal_filter_mode << 1) |
589 (cx->params.video_median_filter_type << 2);
590 cx->params.port = CX2341X_PORT_MEMORY;
591 cx->params.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_AC3;
592 init_waitqueue_head(&cx->cap_w);
593 init_waitqueue_head(&cx->mb_apu_waitq);
594 init_waitqueue_head(&cx->mb_cpu_waitq);
595 init_waitqueue_head(&cx->dma_waitq);
596
597 /* VBI */
598 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
599 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
600
601 /*
602 * The VBI line sizes depend on the pixel clock and the horiz rate
603 *
604 * (1/Fh)*(2*Fp) = Samples/line
605 * = 4 bytes EAV + Anc data in hblank + 4 bytes SAV + active samples
606 *
607 * Sliced VBI is sent as ancillary data during horizontal blanking
608 * Raw VBI is sent as active video samples during vertcal blanking
609 *
610 * We use a BT.656 pxiel clock of 13.5 MHz and a BT.656 active line
611 * length of 720 pixels @ 4:2:2 sampling. Thus...
612 *
613 * For systems that use a 15.734 kHz horizontal rate, such as
614 * NTSC-M, PAL-M, PAL-60, and other 60 Hz/525 line systems, we have:
615 *
616 * (1/15.734 kHz) * 2 * 13.5 MHz = 1716 samples/line =
617 * 4 bytes SAV + 268 bytes anc data + 4 bytes SAV + 1440 active samples
618 *
619 * For systems that use a 15.625 kHz horizontal rate, such as
620 * PAL-B/G/H, PAL-I, SECAM-L and other 50 Hz/625 line systems, we have:
621 *
622 * (1/15.625 kHz) * 2 * 13.5 MHz = 1728 samples/line =
623 * 4 bytes SAV + 280 bytes anc data + 4 bytes SAV + 1440 active samples
624 *
625 */
626
627 /* FIXME: init these based on tuner std & modify when std changes */
628 /* CX18-AV-Core number of VBI samples output per horizontal line */
629 cx->vbi.raw_decoder_line_size = 1444; /* 4 byte SAV + 2 * 720 */
630 cx->vbi.sliced_decoder_line_size = 272; /* 60 Hz: 268+4, 50 Hz: 280+4 */
631
632 /* CX18-AV-Core VBI samples/line possibly rounded up */
633 cx->vbi.raw_size = 1444; /* Real max size is 1444 */
634 cx->vbi.sliced_size = 284; /* Real max size is 284 */
635
636 /*
637 * CX18-AV-Core SAV/EAV RP codes in VIP 1.x mode
638 * Task Field VerticalBlank HorizontalBlank 0 0 0 0
639 */
640 cx->vbi.raw_decoder_sav_odd_field = 0x20; /* V */
641 cx->vbi.raw_decoder_sav_even_field = 0x60; /* FV */
642 cx->vbi.sliced_decoder_sav_odd_field = 0xB0; /* T VH - actually EAV */
643 cx->vbi.sliced_decoder_sav_even_field = 0xF0; /* TFVH - actually EAV */
644 return 0;
645 }
646
647 /* Second initialization part. Here the card type has been
648 autodetected. */
649 static void __devinit cx18_init_struct2(struct cx18 *cx)
650 {
651 int i;
652
653 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
654 if (cx->card->video_inputs[i].video_type == 0)
655 break;
656 cx->nof_inputs = i;
657 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
658 if (cx->card->audio_inputs[i].audio_type == 0)
659 break;
660 cx->nof_audio_inputs = i;
661
662 /* Find tuner input */
663 for (i = 0; i < cx->nof_inputs; i++) {
664 if (cx->card->video_inputs[i].video_type ==
665 CX18_CARD_INPUT_VID_TUNER)
666 break;
667 }
668 if (i == cx->nof_inputs)
669 i = 0;
670 cx->active_input = i;
671 cx->audio_input = cx->card->video_inputs[i].audio_index;
672 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
673 cx->av_state.aud_input = CX18_AV_AUDIO8;
674 cx->av_state.audclk_freq = 48000;
675 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
676 /* FIXME - 8 is NTSC value, investigate */
677 cx->av_state.vbi_line_offset = 8;
678 }
679
680 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
681 const struct pci_device_id *pci_id)
682 {
683 u16 cmd;
684 unsigned char pci_latency;
685
686 CX18_DEBUG_INFO("Enabling pci device\n");
687
688 if (pci_enable_device(pci_dev)) {
689 CX18_ERR("Can't enable device %d!\n", cx->num);
690 return -EIO;
691 }
692 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
693 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
694 return -EIO;
695 }
696 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
697 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
698 return -EIO;
699 }
700
701 /* Enable bus mastering and memory mapped IO for the CX23418 */
702 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
703 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
704 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
705
706 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
707 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
708
709 if (pci_latency < 64 && cx18_pci_latency) {
710 CX18_INFO("Unreasonably low latency timer, "
711 "setting to 64 (was %d)\n", pci_latency);
712 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
713 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
714 }
715
716 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
717 "irq: %d, latency: %d, memory: 0x%lx\n",
718 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
719 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
720 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
721
722 return 0;
723 }
724
725 #ifdef MODULE
726 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
727 const char *name, u32 id)
728 {
729 if ((hw & id) == 0)
730 return hw;
731 if (request_module("%s", name) != 0) {
732 CX18_ERR("Failed to load module %s\n", name);
733 return hw & ~id;
734 }
735 CX18_DEBUG_INFO("Loaded module %s\n", name);
736 return hw;
737 }
738 #endif
739
740 static void cx18_load_and_init_modules(struct cx18 *cx)
741 {
742 u32 hw = cx->card->hw_all;
743 int i;
744
745 #ifdef MODULE
746 /* load modules */
747 #ifdef CONFIG_MEDIA_TUNER_MODULE
748 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
749 #endif
750 #ifdef CONFIG_VIDEO_CS5345_MODULE
751 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
752 #endif
753 #endif
754
755 /* check which i2c devices are actually found */
756 for (i = 0; i < 32; i++) {
757 u32 device = 1 << i;
758
759 if (!(device & hw))
760 continue;
761 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
762 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
763 /* These 'devices' do not use i2c probing */
764 cx->hw_flags |= device;
765 continue;
766 }
767 cx18_i2c_register(cx, i);
768 if (cx18_i2c_hw_addr(cx, device) > 0)
769 cx->hw_flags |= device;
770 }
771
772 hw = cx->hw_flags;
773 }
774
775 static int __devinit cx18_probe(struct pci_dev *pci_dev,
776 const struct pci_device_id *pci_id)
777 {
778 int retval = 0;
779 int i;
780 int vbi_buf_size;
781 u32 devtype;
782 struct cx18 *cx;
783
784 spin_lock(&cx18_cards_lock);
785
786 /* Make sure we've got a place for this card */
787 if (cx18_cards_active == CX18_MAX_CARDS) {
788 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
789 cx18_cards_active);
790 spin_unlock(&cx18_cards_lock);
791 return -ENOMEM;
792 }
793
794 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
795 if (!cx) {
796 spin_unlock(&cx18_cards_lock);
797 return -ENOMEM;
798 }
799 cx18_cards[cx18_cards_active] = cx;
800 cx->num = cx18_cards_active++;
801 snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
802 CX18_INFO("Initializing card #%d\n", cx->num);
803
804 spin_unlock(&cx18_cards_lock);
805
806 cx->pci_dev = pci_dev;
807 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
808 if (retval) {
809 CX18_ERR("Call to v4l2_device_register() failed\n");
810 goto err;
811 }
812 CX18_DEBUG_INFO("registered v4l2_device name: %s\n", cx->v4l2_dev.name);
813
814 cx18_process_options(cx);
815 if (cx->options.cardtype == -1) {
816 retval = -ENODEV;
817 goto unregister_v4l2;
818 }
819 if (cx18_init_struct1(cx)) {
820 retval = -ENOMEM;
821 goto unregister_v4l2;
822 }
823
824 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
825
826 /* PCI Device Setup */
827 retval = cx18_setup_pci(cx, pci_dev, pci_id);
828 if (retval != 0)
829 goto free_workqueue;
830
831 /* map io memory */
832 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
833 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
834 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
835 CX18_MEM_SIZE);
836 if (!cx->enc_mem) {
837 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
838 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
839 retval = -ENOMEM;
840 goto free_mem;
841 }
842 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
843 devtype = cx18_read_reg(cx, 0xC72028);
844 switch (devtype & 0xff000000) {
845 case 0xff000000:
846 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
847 break;
848 case 0x01000000:
849 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
850 break;
851 default:
852 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
853 break;
854 }
855
856 cx18_init_power(cx, 1);
857 cx18_init_memory(cx);
858
859 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
860 cx18_init_scb(cx);
861
862 cx18_gpio_init(cx);
863
864 /* active i2c */
865 CX18_DEBUG_INFO("activating i2c...\n");
866 retval = init_cx18_i2c(cx);
867 if (retval) {
868 CX18_ERR("Could not initialize i2c\n");
869 goto free_map;
870 }
871
872 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
873
874 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
875 /* Based on the model number the cardtype may be changed.
876 The PCI IDs are not always reliable. */
877 cx18_process_eeprom(cx);
878 }
879 if (cx->card->comment)
880 CX18_INFO("%s", cx->card->comment);
881 if (cx->card->v4l2_capabilities == 0) {
882 retval = -ENODEV;
883 goto free_i2c;
884 }
885 cx18_init_memory(cx);
886 cx18_init_scb(cx);
887
888 /* Register IRQ */
889 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
890 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
891 if (retval) {
892 CX18_ERR("Failed to register irq %d\n", retval);
893 goto free_i2c;
894 }
895
896 if (cx->std == 0)
897 cx->std = V4L2_STD_NTSC_M;
898
899 if (cx->options.tuner == -1) {
900 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
901 if ((cx->std & cx->card->tuners[i].std) == 0)
902 continue;
903 cx->options.tuner = cx->card->tuners[i].tuner;
904 break;
905 }
906 }
907 /* if no tuner was found, then pick the first tuner in the card list */
908 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
909 cx->std = cx->card->tuners[0].std;
910 if (cx->std & V4L2_STD_PAL)
911 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
912 else if (cx->std & V4L2_STD_NTSC)
913 cx->std = V4L2_STD_NTSC_M;
914 else if (cx->std & V4L2_STD_SECAM)
915 cx->std = V4L2_STD_SECAM_L;
916 cx->options.tuner = cx->card->tuners[0].tuner;
917 }
918 if (cx->options.radio == -1)
919 cx->options.radio = (cx->card->radio_input.audio_type != 0);
920
921 /* The card is now fully identified, continue with card-specific
922 initialization. */
923 cx18_init_struct2(cx);
924
925 cx18_load_and_init_modules(cx);
926
927 if (cx->std & V4L2_STD_525_60) {
928 cx->is_60hz = 1;
929 cx->is_out_60hz = 1;
930 } else {
931 cx->is_50hz = 1;
932 cx->is_out_50hz = 1;
933 }
934 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
935
936 /*
937 * FIXME: setting the buffer size based on the tuner standard is
938 * suboptimal, as the CVBS and SVideo inputs could use a different std
939 * and the buffer could end up being too small in that case.
940 */
941 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
942 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
943
944 if (cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] < 0)
945 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] =
946 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] * 1024 * 1024
947 / vbi_buf_size;
948 else
949 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] =
950 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] * vbi_buf_size
951 / (1024 * 1024);
952
953 if (cx->options.radio > 0)
954 cx->v4l2_cap |= V4L2_CAP_RADIO;
955
956 if (cx->options.tuner > -1) {
957 struct tuner_setup setup;
958
959 setup.addr = ADDR_UNSET;
960 setup.type = cx->options.tuner;
961 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
962 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
963 cx18_reset_tuner_gpio : NULL;
964 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
965 if (setup.type == TUNER_XC2028) {
966 static struct xc2028_ctrl ctrl = {
967 .fname = XC2028_DEFAULT_FIRMWARE,
968 .max_len = 64,
969 };
970 struct v4l2_priv_tun_config cfg = {
971 .tuner = cx->options.tuner,
972 .priv = &ctrl,
973 };
974 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
975 }
976 }
977
978 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
979 are not. */
980 cx->tuner_std = cx->std;
981
982 retval = cx18_streams_setup(cx);
983 if (retval) {
984 CX18_ERR("Error %d setting up streams\n", retval);
985 goto free_irq;
986 }
987 retval = cx18_streams_register(cx);
988 if (retval) {
989 CX18_ERR("Error %d registering devices\n", retval);
990 goto free_streams;
991 }
992
993 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
994
995 return 0;
996
997 free_streams:
998 cx18_streams_cleanup(cx, 1);
999 free_irq:
1000 free_irq(cx->pci_dev->irq, (void *)cx);
1001 free_i2c:
1002 exit_cx18_i2c(cx);
1003 free_map:
1004 cx18_iounmap(cx);
1005 free_mem:
1006 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1007 free_workqueue:
1008 destroy_workqueue(cx->work_queue);
1009 unregister_v4l2:
1010 v4l2_device_unregister(&cx->v4l2_dev);
1011 err:
1012 if (retval == 0)
1013 retval = -ENODEV;
1014 CX18_ERR("Error %d on initialization\n", retval);
1015
1016 i = cx->num;
1017 spin_lock(&cx18_cards_lock);
1018 kfree(cx18_cards[i]);
1019 cx18_cards[i] = NULL;
1020 spin_unlock(&cx18_cards_lock);
1021 return retval;
1022 }
1023
1024 int cx18_init_on_first_open(struct cx18 *cx)
1025 {
1026 int video_input;
1027 int fw_retry_count = 3;
1028 struct v4l2_frequency vf;
1029 struct cx18_open_id fh;
1030
1031 fh.cx = cx;
1032
1033 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1034 return -ENXIO;
1035
1036 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1037 return 0;
1038
1039 while (--fw_retry_count > 0) {
1040 /* load firmware */
1041 if (cx18_firmware_init(cx) == 0)
1042 break;
1043 if (fw_retry_count > 1)
1044 CX18_WARN("Retry loading firmware\n");
1045 }
1046
1047 if (fw_retry_count == 0) {
1048 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1049 return -ENXIO;
1050 }
1051 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1052
1053 /*
1054 * Init the firmware twice to work around a silicon bug
1055 * with the digital TS.
1056 *
1057 * The second firmware load requires us to normalize the APU state,
1058 * or the audio for the first analog capture will be badly incorrect.
1059 *
1060 * I can't seem to call APU_RESETAI and have it succeed without the
1061 * APU capturing audio, so we start and stop it here to do the reset
1062 */
1063
1064 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1065 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1066 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1067 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1068
1069 fw_retry_count = 3;
1070 while (--fw_retry_count > 0) {
1071 /* load firmware */
1072 if (cx18_firmware_init(cx) == 0)
1073 break;
1074 if (fw_retry_count > 1)
1075 CX18_WARN("Retry loading firmware\n");
1076 }
1077
1078 if (fw_retry_count == 0) {
1079 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1080 return -ENXIO;
1081 }
1082
1083 vf.tuner = 0;
1084 vf.type = V4L2_TUNER_ANALOG_TV;
1085 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1086
1087 /* Set initial frequency. For PAL/SECAM broadcasts no
1088 'default' channel exists AFAIK. */
1089 if (cx->std == V4L2_STD_NTSC_M_JP)
1090 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1091 else if (cx->std & V4L2_STD_NTSC_M)
1092 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1093
1094 video_input = cx->active_input;
1095 cx->active_input++; /* Force update of input */
1096 cx18_s_input(NULL, &fh, video_input);
1097
1098 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1099 in one place. */
1100 cx->std++; /* Force full standard initialization */
1101 cx18_s_std(NULL, &fh, &cx->tuner_std);
1102 cx18_s_frequency(NULL, &fh, &vf);
1103 return 0;
1104 }
1105
1106 static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1107 {
1108 int i;
1109 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1110 cancel_work_sync(&cx->epu_work_order[i].work);
1111 }
1112
1113 static void cx18_remove(struct pci_dev *pci_dev)
1114 {
1115 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1116 struct cx18 *cx = container_of(v4l2_dev, struct cx18, v4l2_dev);
1117
1118 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
1119
1120 /* Stop all captures */
1121 CX18_DEBUG_INFO("Stopping all streams\n");
1122 if (atomic_read(&cx->tot_capturing) > 0)
1123 cx18_stop_all_captures(cx);
1124
1125 /* Interrupts */
1126 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1127 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1128
1129 cx18_halt_firmware(cx);
1130
1131 cx18_cancel_epu_work_orders(cx);
1132
1133 destroy_workqueue(cx->work_queue);
1134
1135 cx18_streams_cleanup(cx, 1);
1136
1137 exit_cx18_i2c(cx);
1138
1139 free_irq(cx->pci_dev->irq, (void *)cx);
1140
1141 cx18_iounmap(cx);
1142
1143 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1144
1145 pci_disable_device(cx->pci_dev);
1146
1147 v4l2_device_unregister(v4l2_dev);
1148
1149 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
1150 }
1151
1152 /* define a pci_driver for card detection */
1153 static struct pci_driver cx18_pci_driver = {
1154 .name = "cx18",
1155 .id_table = cx18_pci_tbl,
1156 .probe = cx18_probe,
1157 .remove = cx18_remove,
1158 };
1159
1160 static int module_start(void)
1161 {
1162 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1163
1164 memset(cx18_cards, 0, sizeof(cx18_cards));
1165
1166 /* Validate parameters */
1167 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1168 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1169 CX18_MAX_CARDS - 1);
1170 return -1;
1171 }
1172
1173 if (cx18_debug < 0 || cx18_debug > 511) {
1174 cx18_debug = 0;
1175 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1176 }
1177
1178 if (pci_register_driver(&cx18_pci_driver)) {
1179 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1180 return -ENODEV;
1181 }
1182 printk(KERN_INFO "cx18: End initialization\n");
1183 return 0;
1184 }
1185
1186 static void module_cleanup(void)
1187 {
1188 int i;
1189
1190 pci_unregister_driver(&cx18_pci_driver);
1191
1192 for (i = 0; i < cx18_cards_active; i++) {
1193 if (cx18_cards[i] == NULL)
1194 continue;
1195 kfree(cx18_cards[i]);
1196 }
1197
1198 }
1199
1200 module_init(module_start);
1201 module_exit(module_cleanup);
Linus' kernel tree