]> 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 (10277): cx18, cx2341x: Fix bugs in cx18 AC3 control and comply with 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
42
43/* var to keep track of the number of array elements in use */
44int 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. */
51int cx18_first_minor;
52
53/* Master variable for all cx18 info */
54struct cx18 *cx18_cards[CX18_MAX_CARDS];
55
56/* Protects cx18_cards_active */
57DEFINE_SPINLOCK(cx18_cards_lock);
58
59/* add your revision and whatnot here */
60static 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
66MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
67
68/* Parameter declarations */
69static int cardtype[CX18_MAX_CARDS];
70static 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 };
74static 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 };
c6eb8eaf
HV		 78static unsigned cardtype_c = 1;
79static unsigned tuner_c = 1;
80static unsigned radio_c = 1;
1c1e45d1
HV		 81static char pal[] = "--";
82static char secam[] = "--";
83static char ntsc[] = "-";
84
85/* Buffers */
1c1e45d1 86static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
6ecd86dc
AW		 87static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
88static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
1c1e45d1
HV		 89static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
90static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
91static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
92
6ecd86dc
AW		 93static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
94static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
95static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
96static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
97/* VBI bufsize based on standards supported by card tuner for now */
98static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
99
100static int enc_ts_bufs = -1;
101static int enc_mpg_bufs = -1;
102static int enc_idx_bufs = -1;
103static int enc_yuv_bufs = -1;
104static int enc_vbi_bufs = -1;
105static int enc_pcm_bufs = -1;
106
107
1c1e45d1
HV		 108static int cx18_pci_latency = 1;
109
3f75c616
AW		 110static int mmio_ndelay;
111static int retry_mmio = 1;
112
1c1e45d1
HV		 113int cx18_debug;
114
115module_param_array(tuner, int, &tuner_c, 0644);
116module_param_array(radio, bool, &radio_c, 0644);
117module_param_array(cardtype, int, &cardtype_c, 0644);
118module_param_string(pal, pal, sizeof(pal), 0644);
119module_param_string(secam, secam, sizeof(secam), 0644);
120module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
121module_param_named(debug, cx18_debug, int, 0644);
3f75c616
AW		 122module_param(mmio_ndelay, int, 0644);
123module_param(retry_mmio, int, 0644);
1c1e45d1
HV		 124module_param(cx18_pci_latency, int, 0644);
125module_param(cx18_first_minor, int, 0644);
126
1c1e45d1 127module_param(enc_ts_buffers, int, 0644);
6ecd86dc
AW		 128module_param(enc_mpg_buffers, int, 0644);
129module_param(enc_idx_buffers, int, 0644);
1c1e45d1
HV		 130module_param(enc_yuv_buffers, int, 0644);
131module_param(enc_vbi_buffers, int, 0644);
132module_param(enc_pcm_buffers, int, 0644);
133
6ecd86dc
AW		 134module_param(enc_ts_bufsize, int, 0644);
135module_param(enc_mpg_bufsize, int, 0644);
136module_param(enc_idx_bufsize, int, 0644);
137module_param(enc_yuv_bufsize, int, 0644);
138/* VBI bufsize based on standards supported by card tuner for now */
139module_param(enc_pcm_bufsize, int, 0644);
140
141module_param(enc_ts_bufs, int, 0644);
142module_param(enc_mpg_bufs, int, 0644);
143module_param(enc_idx_bufs, int, 0644);
144module_param(enc_yuv_bufs, int, 0644);
145module_param(enc_vbi_bufs, int, 0644);
146module_param(enc_pcm_bufs, int, 0644);
147
1c1e45d1
HV		 148MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
149 "\t\t\tsee tuner.h for values");
150MODULE_PARM_DESC(radio,
151 "Enable or disable the radio. Use only if autodetection\n"
152 "\t\t\tfails. 0 = disable, 1 = enable");
153MODULE_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"
03c28085 160 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
9eee4fb6
AW		 161 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
162 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
1c1e45d1
HV		 163 "\t\t\t 0 = Autodetect (default)\n"
164 "\t\t\t-1 = Ignore this card\n\t\t");
165MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
166MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
167MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
168MODULE_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");
179MODULE_PARM_DESC(cx18_pci_latency,
180 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
181 "\t\t\tDefault: Yes");
d267d851 182MODULE_PARM_DESC(retry_mmio,
3f75c616
AW		 183 "(Deprecated) MMIO writes are now always checked and retried\n"
184 "\t\t\tEffectively: 1 [Yes]");
c641d09c 185MODULE_PARM_DESC(mmio_ndelay,
3f75c616
AW		 186 "(Deprecated) MMIO accesses are now never purposely delayed\n"
187 "\t\t\tEffectively: 0 ns");
1c1e45d1 188MODULE_PARM_DESC(enc_ts_buffers,
6ecd86dc 189 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
1c1e45d1 190 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
6ecd86dc
AW		 191MODULE_PARM_DESC(enc_ts_bufsize,
192 "Size of an encoder TS buffer (kB)\n"
193 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
194MODULE_PARM_DESC(enc_ts_bufs,
195 "Number of encoder TS buffers\n"
196 "\t\t\tDefault is computed from other enc_ts_* parameters");
197MODULE_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));
200MODULE_PARM_DESC(enc_mpg_bufsize,
201 "Size of an encoder MPG buffer (kB)\n"
202 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
203MODULE_PARM_DESC(enc_mpg_bufs,
204 "Number of encoder MPG buffers\n"
205 "\t\t\tDefault is computed from other enc_mpg_* parameters");
206MODULE_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));
209MODULE_PARM_DESC(enc_idx_bufsize,
210 "Size of an encoder IDX buffer (kB)\n"
211 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
212MODULE_PARM_DESC(enc_idx_bufs,
213 "Number of encoder IDX buffers\n"
214 "\t\t\tDefault is computed from other enc_idx_* parameters");
1c1e45d1 215MODULE_PARM_DESC(enc_yuv_buffers,
6ecd86dc 216 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
1c1e45d1 217 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
6ecd86dc
AW		 218MODULE_PARM_DESC(enc_yuv_bufsize,
219 "Size of an encoder YUV buffer (kB)\n"
220 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFSIZE));
221MODULE_PARM_DESC(enc_yuv_bufs,
222 "Number of encoder YUV buffers\n"
223 "\t\t\tDefault is computed from other enc_yuv_* parameters");
1c1e45d1 224MODULE_PARM_DESC(enc_vbi_buffers,
6ecd86dc 225 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
1c1e45d1 226 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
6ecd86dc
AW		 227MODULE_PARM_DESC(enc_vbi_bufs,
228 "Number of encoder VBI buffers\n"
229 "\t\t\tDefault is computed from enc_vbi_buffers & tuner std");
1c1e45d1 230MODULE_PARM_DESC(enc_pcm_buffers,
6ecd86dc 231 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
1c1e45d1 232 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
6ecd86dc
AW		 233MODULE_PARM_DESC(enc_pcm_bufsize,
234 "Size of an encoder PCM buffer (kB)\n"
235 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
236MODULE_PARM_DESC(enc_pcm_bufs,
237 "Number of encoder PCM buffers\n"
238 "\t\t\tDefault is computed from other enc_pcm_* parameters");
1c1e45d1 239
dd89601d 240MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
1c1e45d1
HV		 241
242MODULE_AUTHOR("Hans Verkuil");
243MODULE_DESCRIPTION("CX23418 driver");
244MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
245MODULE_LICENSE("GPL");
246
247MODULE_VERSION(CX18_VERSION);
248
1c1e45d1
HV		 249/* Generic utility functions */
250int cx18_msleep_timeout(unsigned int msecs, int intr)
251{
330c6ec8 252 long int timeout = msecs_to_jiffies(msecs);
1c1e45d1
HV		 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 */
264static 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 */
278void 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
287static 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 */
1d081601
HV		 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. */
1c1e45d1 298 switch (tv.model) {
1d081601 299 case 74000 ... 74999:
1c1e45d1
HV		 300 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
301 break;
1c1e45d1
HV		 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
345static 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
427static void cx18_process_options(struct cx18 *cx)
428{
429 int i, j;
430
1c1e45d1 431 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
6ecd86dc
AW		 432 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
433 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
1c1e45d1
HV		 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;
6ecd86dc
AW		 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
1c1e45d1
HV		 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->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->dev->device !=
516 cx->card->pci_list[j].device)
517 continue;
518 if (cx->dev->subsystem_vendor !=
519 cx->card->pci_list[j].subsystem_vendor)
520 continue;
521 if (cx->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 }
529done:
530
531 if (cx->card == NULL) {
532 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
29e66a6c 533 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
1c1e45d1 534 cx->dev->vendor, cx->dev->device);
29e66a6c 535 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
1c1e45d1
HV		 536 cx->dev->subsystem_vendor, cx->dev->subsystem_device);
537 CX18_ERR("Defaulting to %s card\n", cx->card->name);
538 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
539 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
540 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
541 }
542 cx->v4l2_cap = cx->card->v4l2_capabilities;
543 cx->card_name = cx->card->name;
544 cx->card_i2c = cx->card->i2c;
545}
546
547/* Precondition: the cx18 structure has been memset to 0. Only
548 the dev and num fields have been filled in.
549 No assumptions on the card type may be made here (see cx18_init_struct2
550 for that).
551 */
552static int __devinit cx18_init_struct1(struct cx18 *cx)
553{
ee2d64f5
AW		 554 int i;
555
1c1e45d1
HV		 556 cx->base_addr = pci_resource_start(cx->dev, 0);
557
558 mutex_init(&cx->serialize_lock);
559 mutex_init(&cx->i2c_bus_lock[0]);
560 mutex_init(&cx->i2c_bus_lock[1]);
8abdd00d 561 mutex_init(&cx->gpio_lock);
72c2d6d3
AW		 562 mutex_init(&cx->epu2apu_mb_lock);
563 mutex_init(&cx->epu2cpu_mb_lock);
1c1e45d1
HV		 564
565 spin_lock_init(&cx->lock);
1c1e45d1 566
572bfea7
AW		 567 cx->work_queue = create_singlethread_workqueue(cx->name);
568 if (cx->work_queue == NULL) {
569 CX18_ERR("Unable to create work hander thread\n");
570 return -ENOMEM;
571 }
572
ee2d64f5
AW		 573 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++) {
574 cx->epu_work_order[i].cx = cx;
575 cx->epu_work_order[i].str = cx->epu_debug_str;
576 INIT_WORK(&cx->epu_work_order[i].work, cx18_epu_work_handler);
577 }
1d6782bd 578
1c1e45d1
HV		 579 /* start counting open_id at 1 */
580 cx->open_id = 1;
581
582 /* Initial settings */
583 cx2341x_fill_defaults(&cx->params);
584 cx->temporal_strength = cx->params.video_temporal_filter;
585 cx->spatial_strength = cx->params.video_spatial_filter;
586 cx->filter_mode = cx->params.video_spatial_filter_mode |
587 (cx->params.video_temporal_filter_mode << 1) |
588 (cx->params.video_median_filter_type << 2);
589 cx->params.port = CX2341X_PORT_MEMORY;
31230c5f 590 cx->params.capabilities = CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_AC3;
1c1e45d1
HV		 591 init_waitqueue_head(&cx->cap_w);
592 init_waitqueue_head(&cx->mb_apu_waitq);
593 init_waitqueue_head(&cx->mb_cpu_waitq);
1c1e45d1
HV		 594 init_waitqueue_head(&cx->dma_waitq);
595
596 /* VBI */
dd073434 597 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
1c1e45d1 598 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
af009cf6
AW		 599
600 /*
601 * The VBI line sizes depend on the pixel clock and the horiz rate
602 *
603 * (1/Fh)*(2*Fp) = Samples/line
604 * = 4 bytes EAV + Anc data in hblank + 4 bytes SAV + active samples
605 *
606 * Sliced VBI is sent as ancillary data during horizontal blanking
607 * Raw VBI is sent as active video samples during vertcal blanking
608 *
609 * We use a BT.656 pxiel clock of 13.5 MHz and a BT.656 active line
610 * length of 720 pixels @ 4:2:2 sampling. Thus...
611 *
aafc7706
AW		 612 * For systems that use a 15.734 kHz horizontal rate, such as
613 * NTSC-M, PAL-M, PAL-60, and other 60 Hz/525 line systems, we have:
af009cf6 614 *
aafc7706 615 * (1/15.734 kHz) * 2 * 13.5 MHz = 1716 samples/line =
af009cf6
AW		 616 * 4 bytes SAV + 268 bytes anc data + 4 bytes SAV + 1440 active samples
617 *
aafc7706
AW		 618 * For systems that use a 15.625 kHz horizontal rate, such as
619 * PAL-B/G/H, PAL-I, SECAM-L and other 50 Hz/625 line systems, we have:
af009cf6 620 *
aafc7706 621 * (1/15.625 kHz) * 2 * 13.5 MHz = 1728 samples/line =
af009cf6
AW		 622 * 4 bytes SAV + 280 bytes anc data + 4 bytes SAV + 1440 active samples
623 *
624 */
625
aafc7706 626 /* FIXME: init these based on tuner std & modify when std changes */
af009cf6
AW		 627 /* CX18-AV-Core number of VBI samples output per horizontal line */
628 cx->vbi.raw_decoder_line_size = 1444; /* 4 byte SAV + 2 * 720 */
629 cx->vbi.sliced_decoder_line_size = 272; /* 60 Hz: 268+4, 50 Hz: 280+4 */
630
631 /* CX18-AV-Core VBI samples/line possibly rounded up */
632 cx->vbi.raw_size = 1444; /* Real max size is 1444 */
633 cx->vbi.sliced_size = 284; /* Real max size is 284 */
634
635 /*
636 * CX18-AV-Core SAV/EAV RP codes in VIP 1.x mode
637 * Task Field VerticalBlank HorizontalBlank 0 0 0 0
638 */
639 cx->vbi.raw_decoder_sav_odd_field = 0x20; /* V */
640 cx->vbi.raw_decoder_sav_even_field = 0x60; /* FV */
641 cx->vbi.sliced_decoder_sav_odd_field = 0xB0; /* T VH - actually EAV */
642 cx->vbi.sliced_decoder_sav_even_field = 0xF0; /* TFVH - actually EAV */
1c1e45d1
HV		 643 return 0;
644}
645
646/* Second initialization part. Here the card type has been
647 autodetected. */
648static void __devinit cx18_init_struct2(struct cx18 *cx)
649{
650 int i;
651
652 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
653 if (cx->card->video_inputs[i].video_type == 0)
654 break;
655 cx->nof_inputs = i;
656 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
657 if (cx->card->audio_inputs[i].audio_type == 0)
658 break;
659 cx->nof_audio_inputs = i;
660
661 /* Find tuner input */
662 for (i = 0; i < cx->nof_inputs; i++) {
663 if (cx->card->video_inputs[i].video_type ==
664 CX18_CARD_INPUT_VID_TUNER)
665 break;
666 }
667 if (i == cx->nof_inputs)
668 i = 0;
669 cx->active_input = i;
670 cx->audio_input = cx->card->video_inputs[i].audio_index;
671 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
672 cx->av_state.aud_input = CX18_AV_AUDIO8;
673 cx->av_state.audclk_freq = 48000;
674 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
af009cf6 675 /* FIXME - 8 is NTSC value, investigate */
1c1e45d1
HV		 676 cx->av_state.vbi_line_offset = 8;
677}
678
679static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
680 const struct pci_device_id *pci_id)
681{
682 u16 cmd;
683 unsigned char pci_latency;
684
685 CX18_DEBUG_INFO("Enabling pci device\n");
686
687 if (pci_enable_device(dev)) {
688 CX18_ERR("Can't enable device %d!\n", cx->num);
689 return -EIO;
690 }
691 if (pci_set_dma_mask(dev, 0xffffffff)) {
692 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
693 return -EIO;
694 }
695 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
696 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
697 return -EIO;
698 }
699
4519064c 700 /* Enable bus mastering and memory mapped IO for the CX23418 */
1c1e45d1 701 pci_read_config_word(dev, PCI_COMMAND, &cmd);
4519064c 702 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
1c1e45d1
HV		 703 pci_write_config_word(dev, PCI_COMMAND, cmd);
704
705 pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
706 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
707
708 if (pci_latency < 64 && cx18_pci_latency) {
709 CX18_INFO("Unreasonably low latency timer, "
710 "setting to 64 (was %d)\n", pci_latency);
711 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
712 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
713 }
1c1e45d1
HV		 714
715 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
716 "irq: %d, latency: %d, memory: 0x%lx\n",
717 cx->dev->device, cx->card_rev, dev->bus->number,
718 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
719 cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
720
721 return 0;
722}
723
6a4a7935 724#ifdef MODULE
1c1e45d1
HV		 725static u32 cx18_request_module(struct cx18 *cx, u32 hw,
726 const char *name, u32 id)
727{
728 if ((hw & id) == 0)
729 return hw;
730 if (request_module(name) != 0) {
731 CX18_ERR("Failed to load module %s\n", name);
732 return hw & ~id;
733 }
734 CX18_DEBUG_INFO("Loaded module %s\n", name);
735 return hw;
736}
6a4a7935 737#endif
1c1e45d1
HV		 738
739static void cx18_load_and_init_modules(struct cx18 *cx)
740{
741 u32 hw = cx->card->hw_all;
742 int i;
743
6a4a7935 744#ifdef MODULE
1c1e45d1 745 /* load modules */
58ae1c23 746#ifdef CONFIG_MEDIA_TUNER_MODULE
1c1e45d1
HV		 747 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
748#endif
58ae1c23 749#ifdef CONFIG_VIDEO_CS5345_MODULE
1c1e45d1 750 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
6a4a7935 751#endif
1c1e45d1
HV		 752#endif
753
754 /* check which i2c devices are actually found */
755 for (i = 0; i < 32; i++) {
756 u32 device = 1 << i;
757
758 if (!(device & hw))
759 continue;
760 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
761 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
762 /* These 'devices' do not use i2c probing */
763 cx->hw_flags |= device;
764 continue;
765 }
766 cx18_i2c_register(cx, i);
767 if (cx18_i2c_hw_addr(cx, device) > 0)
768 cx->hw_flags |= device;
769 }
770
771 hw = cx->hw_flags;
772}
773
774static int __devinit cx18_probe(struct pci_dev *dev,
775 const struct pci_device_id *pci_id)
776{
777 int retval = 0;
ff086575 778 int i;
1c1e45d1
HV		 779 int vbi_buf_size;
780 u32 devtype;
781 struct cx18 *cx;
782
783 spin_lock(&cx18_cards_lock);
784
785 /* Make sure we've got a place for this card */
786 if (cx18_cards_active == CX18_MAX_CARDS) {
787 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
788 cx18_cards_active);
789 spin_unlock(&cx18_cards_lock);
790 return -ENOMEM;
791 }
792
793 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
cb6969e8 794 if (!cx) {
1c1e45d1
HV		 795 spin_unlock(&cx18_cards_lock);
796 return -ENOMEM;
797 }
798 cx18_cards[cx18_cards_active] = cx;
799 cx->dev = dev;
800 cx->num = cx18_cards_active++;
b4ac3c8d 801 snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
1c1e45d1
HV		 802 CX18_INFO("Initializing card #%d\n", cx->num);
803
804 spin_unlock(&cx18_cards_lock);
805
806 cx18_process_options(cx);
807 if (cx->options.cardtype == -1) {
808 retval = -ENODEV;
809 goto err;
810 }
811 if (cx18_init_struct1(cx)) {
812 retval = -ENOMEM;
813 goto err;
814 }
815
816 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
817
818 /* PCI Device Setup */
819 retval = cx18_setup_pci(cx, dev, pci_id);
572bfea7
AW		 820 if (retval != 0)
821 goto free_workqueue;
822
1c1e45d1
HV		 823 /* save cx in the pci struct for later use */
824 pci_set_drvdata(dev, cx);
825
826 /* map io memory */
827 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
828 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
829 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
830 CX18_MEM_SIZE);
831 if (!cx->enc_mem) {
832 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
833 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
834 retval = -ENOMEM;
835 goto free_mem;
836 }
837 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
b1526421 838 devtype = cx18_read_reg(cx, 0xC72028);
1c1e45d1
HV		 839 switch (devtype & 0xff000000) {
840 case 0xff000000:
841 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
842 break;
843 case 0x01000000:
844 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
845 break;
846 default:
847 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
848 break;
849 }
850
851 cx18_init_power(cx, 1);
852 cx18_init_memory(cx);
853
990c81c8 854 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
1c1e45d1
HV		 855 cx18_init_scb(cx);
856
857 cx18_gpio_init(cx);
858
859 /* active i2c */
860 CX18_DEBUG_INFO("activating i2c...\n");
9b4a7c8a
AW		 861 retval = init_cx18_i2c(cx);
862 if (retval) {
1c1e45d1
HV		 863 CX18_ERR("Could not initialize i2c\n");
864 goto free_map;
865 }
866
867 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
868
869 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
870 /* Based on the model number the cardtype may be changed.
871 The PCI IDs are not always reliable. */
872 cx18_process_eeprom(cx);
873 }
874 if (cx->card->comment)
875 CX18_INFO("%s", cx->card->comment);
876 if (cx->card->v4l2_capabilities == 0) {
877 retval = -ENODEV;
878 goto free_i2c;
879 }
880 cx18_init_memory(cx);
fd6b9c97 881 cx18_init_scb(cx);
1c1e45d1
HV		 882
883 /* Register IRQ */
884 retval = request_irq(cx->dev->irq, cx18_irq_handler,
885 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
886 if (retval) {
887 CX18_ERR("Failed to register irq %d\n", retval);
888 goto free_i2c;
889 }
890
891 if (cx->std == 0)
892 cx->std = V4L2_STD_NTSC_M;
893
894 if (cx->options.tuner == -1) {
1c1e45d1
HV		 895 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
896 if ((cx->std & cx->card->tuners[i].std) == 0)
897 continue;
898 cx->options.tuner = cx->card->tuners[i].tuner;
899 break;
900 }
901 }
902 /* if no tuner was found, then pick the first tuner in the card list */
903 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
904 cx->std = cx->card->tuners[0].std;
c3cb4d95
HV		 905 if (cx->std & V4L2_STD_PAL)
906 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
907 else if (cx->std & V4L2_STD_NTSC)
908 cx->std = V4L2_STD_NTSC_M;
909 else if (cx->std & V4L2_STD_SECAM)
910 cx->std = V4L2_STD_SECAM_L;
1c1e45d1
HV		 911 cx->options.tuner = cx->card->tuners[0].tuner;
912 }
913 if (cx->options.radio == -1)
914 cx->options.radio = (cx->card->radio_input.audio_type != 0);
915
916 /* The card is now fully identified, continue with card-specific
917 initialization. */
918 cx18_init_struct2(cx);
919
920 cx18_load_and_init_modules(cx);
921
922 if (cx->std & V4L2_STD_525_60) {
923 cx->is_60hz = 1;
924 cx->is_out_60hz = 1;
925 } else {
926 cx->is_50hz = 1;
927 cx->is_out_50hz = 1;
928 }
929 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
930
aafc7706
AW		 931 /*
932 * FIXME: setting the buffer size based on the tuner standard is
933 * suboptimal, as the CVBS and SVideo inputs could use a different std
934 * and the buffer could end up being too small in that case.
935 */
1c1e45d1
HV		 936 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
937 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
938
6ecd86dc
AW		 939 if (cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] < 0)
940 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] =
941 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] * 1024 * 1024
942 / vbi_buf_size;
943 else
944 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] =
945 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] * vbi_buf_size
946 / (1024 * 1024);
947
1c1e45d1
HV		 948 if (cx->options.radio > 0)
949 cx->v4l2_cap |= V4L2_CAP_RADIO;
950
1c1e45d1
HV		 951 if (cx->options.tuner > -1) {
952 struct tuner_setup setup;
953
954 setup.addr = ADDR_UNSET;
955 setup.type = cx->options.tuner;
956 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
957 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
958 cx18_reset_tuner_gpio : NULL;
959 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
960 if (setup.type == TUNER_XC2028) {
961 static struct xc2028_ctrl ctrl = {
962 .fname = XC2028_DEFAULT_FIRMWARE,
963 .max_len = 64,
964 };
965 struct v4l2_priv_tun_config cfg = {
966 .tuner = cx->options.tuner,
967 .priv = &ctrl,
968 };
969 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
970 }
971 }
972
973 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
974 are not. */
975 cx->tuner_std = cx->std;
976
5e7fdc5e
HV		 977 retval = cx18_streams_setup(cx);
978 if (retval) {
979 CX18_ERR("Error %d setting up streams\n", retval);
980 goto free_irq;
981 }
982 retval = cx18_streams_register(cx);
983 if (retval) {
984 CX18_ERR("Error %d registering devices\n", retval);
985 goto free_streams;
986 }
1c1e45d1
HV		 987
988 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
989
990 return 0;
991
992free_streams:
3f98387e 993 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 994free_irq:
995 free_irq(cx->dev->irq, (void *)cx);
996free_i2c:
997 exit_cx18_i2c(cx);
998free_map:
999 cx18_iounmap(cx);
1000free_mem:
1001 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1002free_workqueue:
572bfea7 1003 destroy_workqueue(cx->work_queue);
1c1e45d1
HV		 1004err:
1005 if (retval == 0)
1006 retval = -ENODEV;
1007 CX18_ERR("Error %d on initialization\n", retval);
1008
ff086575
AW		 1009 i = cx->num;
1010 spin_lock(&cx18_cards_lock);
1011 kfree(cx18_cards[i]);
1012 cx18_cards[i] = NULL;
1013 spin_unlock(&cx18_cards_lock);
1c1e45d1
HV		 1014 return retval;
1015}
1016
1017int cx18_init_on_first_open(struct cx18 *cx)
1018{
1019 int video_input;
1020 int fw_retry_count = 3;
1021 struct v4l2_frequency vf;
3b6fe58f
AW		 1022 struct cx18_open_id fh;
1023
1024 fh.cx = cx;
1c1e45d1
HV		 1025
1026 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1027 return -ENXIO;
1028
1029 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1030 return 0;
1031
1032 while (--fw_retry_count > 0) {
1033 /* load firmware */
1034 if (cx18_firmware_init(cx) == 0)
1035 break;
1036 if (fw_retry_count > 1)
1037 CX18_WARN("Retry loading firmware\n");
1038 }
1039
1040 if (fw_retry_count == 0) {
1041 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1042 return -ENXIO;
1043 }
1044 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1045
1046 /* Init the firmware twice to work around a silicon bug
1047 * transport related. */
1048
1049 fw_retry_count = 3;
1050 while (--fw_retry_count > 0) {
1051 /* load firmware */
1052 if (cx18_firmware_init(cx) == 0)
1053 break;
1054 if (fw_retry_count > 1)
1055 CX18_WARN("Retry loading firmware\n");
1056 }
1057
1058 if (fw_retry_count == 0) {
1059 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1060 return -ENXIO;
1061 }
1062
1063 vf.tuner = 0;
1064 vf.type = V4L2_TUNER_ANALOG_TV;
1065 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1066
1067 /* Set initial frequency. For PAL/SECAM broadcasts no
1068 'default' channel exists AFAIK. */
1069 if (cx->std == V4L2_STD_NTSC_M_JP)
1070 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1071 else if (cx->std & V4L2_STD_NTSC_M)
1072 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1073
1074 video_input = cx->active_input;
1075 cx->active_input++; /* Force update of input */
3b6fe58f 1076 cx18_s_input(NULL, &fh, video_input);
1c1e45d1
HV		 1077
1078 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1079 in one place. */
1080 cx->std++; /* Force full standard initialization */
3b6fe58f
AW		 1081 cx18_s_std(NULL, &fh, &cx->tuner_std);
1082 cx18_s_frequency(NULL, &fh, &vf);
1c1e45d1
HV		 1083 return 0;
1084}
1085
18b5dc2e
AW		 1086static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1087{
1088 int i;
1089 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1090 cancel_work_sync(&cx->epu_work_order[i].work);
1091}
1092
1c1e45d1
HV		 1093static void cx18_remove(struct pci_dev *pci_dev)
1094{
1095 struct cx18 *cx = pci_get_drvdata(pci_dev);
1096
1097 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
1098
1099 /* Stop all captures */
1100 CX18_DEBUG_INFO("Stopping all streams\n");
31554ae5 1101 if (atomic_read(&cx->tot_capturing) > 0)
1c1e45d1
HV		 1102 cx18_stop_all_captures(cx);
1103
1104 /* Interrupts */
b1526421
AW		 1105 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1106 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1c1e45d1
HV		 1107
1108 cx18_halt_firmware(cx);
1109
18b5dc2e 1110 cx18_cancel_epu_work_orders(cx);
1d6782bd 1111
572bfea7
AW		 1112 destroy_workqueue(cx->work_queue);
1113
3f98387e 1114 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 1115
1116 exit_cx18_i2c(cx);
1117
1118 free_irq(cx->dev->irq, (void *)cx);
1119
cba627a5 1120 cx18_iounmap(cx);
1c1e45d1
HV		 1121
1122 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1123
1124 pci_disable_device(cx->dev);
1125
1126 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
1127}
1128
1129/* define a pci_driver for card detection */
1130static struct pci_driver cx18_pci_driver = {
1131 .name = "cx18",
1132 .id_table = cx18_pci_tbl,
1133 .probe = cx18_probe,
1134 .remove = cx18_remove,
1135};
1136
1137static int module_start(void)
1138{
1139 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1140
1141 memset(cx18_cards, 0, sizeof(cx18_cards));
1142
1143 /* Validate parameters */
1144 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
dd89601d 1145 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1c1e45d1
HV		 1146 CX18_MAX_CARDS - 1);
1147 return -1;
1148 }
1149
1150 if (cx18_debug < 0 || cx18_debug > 511) {
1151 cx18_debug = 0;
1152 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1153 }
1154
1155 if (pci_register_driver(&cx18_pci_driver)) {
1156 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1157 return -ENODEV;
1158 }
1159 printk(KERN_INFO "cx18: End initialization\n");
1160 return 0;
1161}
1162
1163static void module_cleanup(void)
1164{
1165 int i;
1166
1167 pci_unregister_driver(&cx18_pci_driver);
1168
1169 for (i = 0; i < cx18_cards_active; i++) {
1170 if (cx18_cards[i] == NULL)
1171 continue;
1172 kfree(cx18_cards[i]);
1173 }
18b5dc2e 1174
1c1e45d1
HV		 1175}
1176
1177module_init(module_start);
1178module_exit(module_cleanup);
Ubuntu Hirsute Linux kernel mirror