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