projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / video / cx18 / cx18-driver.c
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-queue.h"
34 #include "cx18-streams.h"
35 #include "cx18-av-core.h"
36 #include "cx18-scb.h"
37 #include "cx18-mailbox.h"
38 #include "cx18-ioctl.h"
39 #include "tuner-xc2028.h"
40
41 #include <media/tveeprom.h>
42
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. */
48 int cx18_first_minor;
49
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},
54 {0,}
55 };
56
57 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
58
59 static atomic_t cx18_instance = ATOMIC_INIT(0);
60
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[] = "-";
77
78 /* Buffers */
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;
85
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;
92
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;
99
100
101 static int cx18_pci_latency = 1;
102
103 static int mmio_ndelay;
104 static int retry_mmio = 1;
105
106 int cx18_debug;
107
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);
119
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);
126
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);
133
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);
140
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");
233
234 MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
235
236 MODULE_AUTHOR("Hans Verkuil");
237 MODULE_DESCRIPTION("CX23418 driver");
238 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
239 MODULE_LICENSE("GPL");
240
241 MODULE_VERSION(CX18_VERSION);
242
243 /* Generic utility functions */
244 int cx18_msleep_timeout(unsigned int msecs, int intr)
245 {
246 long int timeout = msecs_to_jiffies(msecs);
247 int sig;
248
249 do {
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);
254 return sig;
255 }
256
257 /* Release ioremapped memory */
258 static void cx18_iounmap(struct cx18 *cx)
259 {
260 if (cx == NULL)
261 return;
262
263 /* Release io memory */
264 if (cx->enc_mem != NULL) {
265 CX18_DEBUG_INFO("releasing enc_mem\n");
266 iounmap(cx->enc_mem);
267 cx->enc_mem = NULL;
268 }
269 }
270
271 static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
272 {
273 int i;
274
275 CX18_INFO("eeprom dump:\n");
276 for (i = 0; i < len; i++) {
277 if (0 == (i % 16))
278 CX18_INFO("eeprom %02x:", i);
279 printk(KERN_CONT " %02x", eedata[i]);
280 if (15 == (i % 16))
281 printk(KERN_CONT "\n");
282 }
283 }
284
285 /* Hauppauge card? get values from tveeprom */
286 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
287 {
288 struct i2c_client c;
289 u8 eedata[256];
290
291 memset(&c, 0, sizeof(c));
292 strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
293 c.adapter = &cx->i2c_adap[0];
294 c.addr = 0xA0 >> 1;
295
296 memset(tv, 0, sizeof(*tv));
297 if (tveeprom_read(&c, eedata, sizeof(eedata)))
298 return;
299
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);
304 break;
305 case CX18_CARD_YUAN_MPC718:
306 tv->model = 0x718;
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]);
310 break;
311 default:
312 tv->model = 0xffffffff;
313 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
314 break;
315 }
316 }
317
318 static void cx18_process_eeprom(struct cx18 *cx)
319 {
320 struct tveeprom tv;
321
322 cx18_read_eeprom(cx, &tv);
323
324 /* Many thanks to Steven Toth from Hauppauge for providing the
325 model numbers */
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. */
329 switch (tv.model) {
330 case 74000 ... 74999:
331 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
332 break;
333 case 0x718:
334 return;
335 case 0xffffffff:
336 CX18_INFO("Unknown EEPROM encoding\n");
337 return;
338 case 0:
339 CX18_ERR("Invalid EEPROM\n");
340 return;
341 default:
342 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
343 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
344 break;
345 }
346
347 cx->v4l2_cap = cx->card->v4l2_capabilities;
348 cx->card_name = cx->card->name;
349 cx->card_i2c = cx->card->i2c;
350
351 CX18_INFO("Autodetected %s\n", cx->card_name);
352
353 if (tv.tuner_type == TUNER_ABSENT)
354 CX18_ERR("tveeprom cannot autodetect tuner!\n");
355
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);
360
361 if (cx->std != 0)
362 /* user specified tuner standard */
363 return;
364
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;
375 } else {
376 CX18_INFO("No tuner detected, default to NTSC-M\n");
377 cx->std |= V4L2_STD_NTSC_M;
378 }
379 }
380
381 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
382 {
383 switch (pal[0]) {
384 case '6':
385 return V4L2_STD_PAL_60;
386 case 'b':
387 case 'B':
388 case 'g':
389 case 'G':
390 return V4L2_STD_PAL_BG;
391 case 'h':
392 case 'H':
393 return V4L2_STD_PAL_H;
394 case 'n':
395 case 'N':
396 if (pal[1] == 'c' || pal[1] == 'C')
397 return V4L2_STD_PAL_Nc;
398 return V4L2_STD_PAL_N;
399 case 'i':
400 case 'I':
401 return V4L2_STD_PAL_I;
402 case 'd':
403 case 'D':
404 case 'k':
405 case 'K':
406 return V4L2_STD_PAL_DK;
407 case 'M':
408 case 'm':
409 return V4L2_STD_PAL_M;
410 case '-':
411 break;
412 default:
413 CX18_WARN("pal= argument not recognised\n");
414 return 0;
415 }
416
417 switch (secam[0]) {
418 case 'b':
419 case 'B':
420 case 'g':
421 case 'G':
422 case 'h':
423 case 'H':
424 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
425 case 'd':
426 case 'D':
427 case 'k':
428 case 'K':
429 return V4L2_STD_SECAM_DK;
430 case 'l':
431 case 'L':
432 if (secam[1] == 'C' || secam[1] == 'c')
433 return V4L2_STD_SECAM_LC;
434 return V4L2_STD_SECAM_L;
435 case '-':
436 break;
437 default:
438 CX18_WARN("secam= argument not recognised\n");
439 return 0;
440 }
441
442 switch (ntsc[0]) {
443 case 'm':
444 case 'M':
445 return V4L2_STD_NTSC_M;
446 case 'j':
447 case 'J':
448 return V4L2_STD_NTSC_M_JP;
449 case 'k':
450 case 'K':
451 return V4L2_STD_NTSC_M_KR;
452 case '-':
453 break;
454 default:
455 CX18_WARN("ntsc= argument not recognised\n");
456 return 0;
457 }
458
459 /* no match found */
460 return 0;
461 }
462
463 static void cx18_process_options(struct cx18 *cx)
464 {
465 int i, j;
466
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 */
474
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 */
482
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 */
490
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;
499 continue;
500 }
501 /*
502 * VBI is a special case where the stream_buf_size is fixed
503 * and already in bytes
504 */
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];
510 } else {
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);
515 }
516 continue;
517 }
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];
522 } else {
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;
526 }
527 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
528 }
529
530 cx->options.cardtype = cardtype[cx->instance];
531 cx->options.tuner = tuner[cx->instance];
532 cx->options.radio = radio[cx->instance];
533
534 cx->std = cx18_parse_std(cx);
535 if (cx->options.cardtype == -1) {
536 CX18_INFO("Ignore card\n");
537 return;
538 }
539 cx->card = cx18_get_card(cx->options.cardtype - 1);
540 if (cx->card)
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");
548 }
549 }
550 if (cx->card == NULL) {
551 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
552 if (cx->card->pci_list == NULL)
553 continue;
554 for (j = 0; cx->card->pci_list[j].device; j++) {
555 if (cx->pci_dev->device !=
556 cx->card->pci_list[j].device)
557 continue;
558 if (cx->pci_dev->subsystem_vendor !=
559 cx->card->pci_list[j].subsystem_vendor)
560 continue;
561 if (cx->pci_dev->subsystem_device !=
562 cx->card->pci_list[j].subsystem_device)
563 continue;
564 CX18_INFO("Autodetected %s card\n", cx->card->name);
565 goto done;
566 }
567 }
568 }
569 done:
570
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");
582 }
583 cx->v4l2_cap = cx->card->v4l2_capabilities;
584 cx->card_name = cx->card->name;
585 cx->card_i2c = cx->card->i2c;
586 }
587
588 static int __devinit cx18_create_in_workq(struct cx18 *cx)
589 {
590 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
591 cx->v4l2_dev.name);
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");
595 return -ENOMEM;
596 }
597 return 0;
598 }
599
600 static int __devinit cx18_create_out_workq(struct cx18 *cx)
601 {
602 snprintf(cx->out_workq_name, sizeof(cx->out_workq_name), "%s-out",
603 cx->v4l2_dev.name);
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");
607 return -ENOMEM;
608 }
609 return 0;
610 }
611
612 static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
613 {
614 int i;
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);
619 }
620 }
621
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
625 for that).
626 */
627 static int __devinit cx18_init_struct1(struct cx18 *cx)
628 {
629 int ret;
630
631 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
632
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);
637
638 ret = cx18_create_out_workq(cx);
639 if (ret)
640 return ret;
641
642 ret = cx18_create_in_workq(cx);
643 if (ret) {
644 destroy_workqueue(cx->out_work_queue);
645 return ret;
646 }
647
648 cx18_init_in_work_orders(cx);
649
650 /* start counting open_id at 1 */
651 cx->open_id = 1;
652
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);
667
668 /* VBI */
669 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
670 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
671
672 return 0;
673 }
674
675 /* Second initialization part. Here the card type has been
676 autodetected. */
677 static void __devinit cx18_init_struct2(struct cx18 *cx)
678 {
679 int i;
680
681 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
682 if (cx->card->video_inputs[i].video_type == 0)
683 break;
684 cx->nof_inputs = i;
685 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
686 if (cx->card->audio_inputs[i].audio_type == 0)
687 break;
688 cx->nof_audio_inputs = i;
689
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)
694 break;
695 }
696 if (i == cx->nof_inputs)
697 i = 0;
698 cx->active_input = i;
699 cx->audio_input = cx->card->video_inputs[i].audio_index;
700 }
701
702 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
703 const struct pci_device_id *pci_id)
704 {
705 u16 cmd;
706 unsigned char pci_latency;
707
708 CX18_DEBUG_INFO("Enabling pci device\n");
709
710 if (pci_enable_device(pci_dev)) {
711 CX18_ERR("Can't enable device %d!\n", cx->instance);
712 return -EIO;
713 }
714 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
715 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
716 return -EIO;
717 }
718 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
719 CX18_ERR("Cannot request encoder memory region, card %d\n",
720 cx->instance);
721 return -EIO;
722 }
723
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);
728
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);
731
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);
737 }
738
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);
744
745 return 0;
746 }
747
748 static void cx18_init_subdevs(struct cx18 *cx)
749 {
750 u32 hw = cx->card->hw_all;
751 u32 device;
752 int i;
753
754 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
755
756 if (!(device & hw))
757 continue;
758
759 switch (device) {
760 case CX18_HW_DVB:
761 case CX18_HW_TVEEPROM:
762 /* These subordinate devices do not use probing */
763 cx->hw_flags |= device;
764 break;
765 case CX18_HW_418_AV:
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;
769 break;
770 case CX18_HW_GPIO_RESET_CTRL:
771 /*
772 * The Reset Controller gets probed and added to
773 * hw_flags earlier for i2c adapter/bus initialization
774 */
775 break;
776 case CX18_HW_GPIO_MUX:
777 if (cx18_gpio_register(cx, device) == 0)
778 cx->hw_flags |= device;
779 break;
780 default:
781 if (cx18_i2c_register(cx, i) == 0)
782 cx->hw_flags |= device;
783 break;
784 }
785 }
786
787 if (cx->hw_flags & CX18_HW_418_AV)
788 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
789
790 if (cx->card->hw_muxer != 0)
791 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
792 }
793
794 static int __devinit cx18_probe(struct pci_dev *pci_dev,
795 const struct pci_device_id *pci_id)
796 {
797 int retval = 0;
798 int i;
799 u32 devtype;
800 struct cx18 *cx;
801
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);
807 return -ENOMEM;
808 }
809
810 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
811 if (cx == NULL) {
812 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
813 i);
814 return -ENOMEM;
815 }
816 cx->pci_dev = pci_dev;
817 cx->instance = i;
818
819 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
820 if (retval) {
821 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
822 "\n", cx->instance);
823 kfree(cx);
824 return retval;
825 }
826 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
827 cx->instance);
828 CX18_INFO("Initializing card %d\n", cx->instance);
829
830 cx18_process_options(cx);
831 if (cx->options.cardtype == -1) {
832 retval = -ENODEV;
833 goto err;
834 }
835
836 retval = cx18_init_struct1(cx);
837 if (retval)
838 goto err;
839
840 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
841
842 /* PCI Device Setup */
843 retval = cx18_setup_pci(cx, pci_dev, pci_id);
844 if (retval != 0)
845 goto free_workqueues;
846
847 /* map io memory */
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,
851 CX18_MEM_SIZE);
852 if (!cx->enc_mem) {
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");
855 retval = -ENOMEM;
856 goto free_mem;
857 }
858 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
859 devtype = cx18_read_reg(cx, 0xC72028);
860 switch (devtype & 0xff000000) {
861 case 0xff000000:
862 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
863 break;
864 case 0x01000000:
865 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
866 break;
867 default:
868 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
869 break;
870 }
871
872 cx18_init_power(cx, 1);
873 cx18_init_memory(cx);
874
875 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
876 cx18_init_scb(cx);
877
878 cx18_gpio_init(cx);
879
880 /* Initialize integrated A/V decoder early to set PLLs, just in case */
881 retval = cx18_av_probe(cx);
882 if (retval) {
883 CX18_ERR("Could not register A/V decoder subdevice\n");
884 goto free_map;
885 }
886 cx18_call_hw(cx, CX18_HW_418_AV, core, init, 0);
887
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");
893 else
894 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
895 }
896
897 /* active i2c */
898 CX18_DEBUG_INFO("activating i2c...\n");
899 retval = init_cx18_i2c(cx);
900 if (retval) {
901 CX18_ERR("Could not initialize i2c\n");
902 goto free_map;
903 }
904
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);
909 }
910 if (cx->card->comment)
911 CX18_INFO("%s", cx->card->comment);
912 if (cx->card->v4l2_capabilities == 0) {
913 retval = -ENODEV;
914 goto free_i2c;
915 }
916 cx18_init_memory(cx);
917 cx18_init_scb(cx);
918
919 /* Register IRQ */
920 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
921 IRQF_SHARED | IRQF_DISABLED,
922 cx->v4l2_dev.name, (void *)cx);
923 if (retval) {
924 CX18_ERR("Failed to register irq %d\n", retval);
925 goto free_i2c;
926 }
927
928 if (cx->std == 0)
929 cx->std = V4L2_STD_NTSC_M;
930
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)
934 continue;
935 cx->options.tuner = cx->card->tuners[i].tuner;
936 break;
937 }
938 }
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;
949 }
950 if (cx->options.radio == -1)
951 cx->options.radio = (cx->card->radio_input.audio_type != 0);
952
953 /* The card is now fully identified, continue with card-specific
954 initialization. */
955 cx18_init_struct2(cx);
956
957 cx18_init_subdevs(cx);
958
959 if (cx->std & V4L2_STD_525_60)
960 cx->is_60hz = 1;
961 else
962 cx->is_50hz = 1;
963
964 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
965
966 if (cx->options.radio > 0)
967 cx->v4l2_cap |= V4L2_CAP_RADIO;
968
969 if (cx->options.tuner > -1) {
970 struct tuner_setup setup;
971
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,
981 .max_len = 64,
982 };
983 struct v4l2_priv_tun_config cfg = {
984 .tuner = cx->options.tuner,
985 .priv = &ctrl,
986 };
987 cx18_call_all(cx, tuner, s_config, &cfg);
988 }
989 }
990
991 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
992 are not. */
993 cx->tuner_std = cx->std;
994
995 retval = cx18_streams_setup(cx);
996 if (retval) {
997 CX18_ERR("Error %d setting up streams\n", retval);
998 goto free_irq;
999 }
1000 retval = cx18_streams_register(cx);
1001 if (retval) {
1002 CX18_ERR("Error %d registering devices\n", retval);
1003 goto free_streams;
1004 }
1005
1006 CX18_INFO("Initialized card: %s\n", cx->card_name);
1007 return 0;
1008
1009 free_streams:
1010 cx18_streams_cleanup(cx, 1);
1011 free_irq:
1012 free_irq(cx->pci_dev->irq, (void *)cx);
1013 free_i2c:
1014 exit_cx18_i2c(cx);
1015 free_map:
1016 cx18_iounmap(cx);
1017 free_mem:
1018 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1019 free_workqueues:
1020 destroy_workqueue(cx->in_work_queue);
1021 destroy_workqueue(cx->out_work_queue);
1022 err:
1023 if (retval == 0)
1024 retval = -ENODEV;
1025 CX18_ERR("Error %d on initialization\n", retval);
1026
1027 v4l2_device_unregister(&cx->v4l2_dev);
1028 kfree(cx);
1029 return retval;
1030 }
1031
1032 int cx18_init_on_first_open(struct cx18 *cx)
1033 {
1034 int video_input;
1035 int fw_retry_count = 3;
1036 struct v4l2_frequency vf;
1037 struct cx18_open_id fh;
1038
1039 fh.cx = cx;
1040
1041 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1042 return -ENXIO;
1043
1044 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1045 return 0;
1046
1047 while (--fw_retry_count > 0) {
1048 /* load firmware */
1049 if (cx18_firmware_init(cx) == 0)
1050 break;
1051 if (fw_retry_count > 1)
1052 CX18_WARN("Retry loading firmware\n");
1053 }
1054
1055 if (fw_retry_count == 0) {
1056 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1057 return -ENXIO;
1058 }
1059 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1060
1061 /*
1062 * Init the firmware twice to work around a silicon bug
1063 * with the digital TS.
1064 *
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.
1067 *
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
1070 */
1071
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);
1076
1077 fw_retry_count = 3;
1078 while (--fw_retry_count > 0) {
1079 /* load firmware */
1080 if (cx18_firmware_init(cx) == 0)
1081 break;
1082 if (fw_retry_count > 1)
1083 CX18_WARN("Retry loading firmware\n");
1084 }
1085
1086 if (fw_retry_count == 0) {
1087 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1088 return -ENXIO;
1089 }
1090
1091 /*
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.
1094 *
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
1097 */
1098
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);
1103
1104 /* Init the A/V decoder, if it hasn't been already */
1105 v4l2_subdev_call(cx->sd_av, core, load_fw);
1106
1107 vf.tuner = 0;
1108 vf.type = V4L2_TUNER_ANALOG_TV;
1109 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1110
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 */
1117
1118 video_input = cx->active_input;
1119 cx->active_input++; /* Force update of input */
1120 cx18_s_input(NULL, &fh, video_input);
1121
1122 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1123 in one place. */
1124 cx->std++; /* Force full standard initialization */
1125 cx18_s_std(NULL, &fh, &cx->tuner_std);
1126 cx18_s_frequency(NULL, &fh, &vf);
1127 return 0;
1128 }
1129
1130 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1131 {
1132 int i;
1133 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1134 cancel_work_sync(&cx->in_work_order[i].work);
1135 }
1136
1137 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1138 {
1139 int i;
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);
1143 }
1144
1145 static void cx18_remove(struct pci_dev *pci_dev)
1146 {
1147 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1148 struct cx18 *cx = to_cx18(v4l2_dev);
1149 int i;
1150
1151 CX18_DEBUG_INFO("Removing Card\n");
1152
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);
1157
1158 /* Stop interrupts that cause incoming work to be queued */
1159 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1160
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);
1164
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);
1167
1168 cx18_halt_firmware(cx);
1169
1170 destroy_workqueue(cx->in_work_queue);
1171 destroy_workqueue(cx->out_work_queue);
1172
1173 cx18_streams_cleanup(cx, 1);
1174
1175 exit_cx18_i2c(cx);
1176
1177 free_irq(cx->pci_dev->irq, (void *)cx);
1178
1179 cx18_iounmap(cx);
1180
1181 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1182
1183 pci_disable_device(cx->pci_dev);
1184
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]);
1188
1189 CX18_INFO("Removed %s\n", cx->card_name);
1190
1191 v4l2_device_unregister(v4l2_dev);
1192 kfree(cx);
1193 }
1194
1195 /* define a pci_driver for card detection */
1196 static struct pci_driver cx18_pci_driver = {
1197 .name = "cx18",
1198 .id_table = cx18_pci_tbl,
1199 .probe = cx18_probe,
1200 .remove = cx18_remove,
1201 };
1202
1203 static int module_start(void)
1204 {
1205 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1206
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);
1211 return -1;
1212 }
1213
1214 if (cx18_debug < 0 || cx18_debug > 511) {
1215 cx18_debug = 0;
1216 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1217 }
1218
1219 if (pci_register_driver(&cx18_pci_driver)) {
1220 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1221 return -ENODEV;
1222 }
1223 printk(KERN_INFO "cx18: End initialization\n");
1224 return 0;
1225 }
1226
1227 static void module_cleanup(void)
1228 {
1229 pci_unregister_driver(&cx18_pci_driver);
1230 }
1231
1232 module_init(module_start);
1233 module_exit(module_cleanup);
kernel source for telekom puls (alcatel/mediatek)