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