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