projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (13899): gspca - all subdrivers: Make control descriptors constant.
[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;
6ecd86dc
AW		 90static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
91
92static int enc_ts_bufs = -1;
93static int enc_mpg_bufs = -1;
94static int enc_idx_bufs = -1;
95static int enc_yuv_bufs = -1;
96static int enc_vbi_bufs = -1;
97static int enc_pcm_bufs = -1;
98
99
1c1e45d1
HV		 100static int cx18_pci_latency = 1;
101
3f75c616
AW		 102static int mmio_ndelay;
103static int retry_mmio = 1;
104
1c1e45d1
HV		 105int cx18_debug;
106
107module_param_array(tuner, int, &tuner_c, 0644);
108module_param_array(radio, bool, &radio_c, 0644);
109module_param_array(cardtype, int, &cardtype_c, 0644);
110module_param_string(pal, pal, sizeof(pal), 0644);
111module_param_string(secam, secam, sizeof(secam), 0644);
112module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
113module_param_named(debug, cx18_debug, int, 0644);
3f75c616
AW		 114module_param(mmio_ndelay, int, 0644);
115module_param(retry_mmio, int, 0644);
1c1e45d1
HV		 116module_param(cx18_pci_latency, int, 0644);
117module_param(cx18_first_minor, int, 0644);
118
1c1e45d1 119module_param(enc_ts_buffers, int, 0644);
6ecd86dc
AW		 120module_param(enc_mpg_buffers, int, 0644);
121module_param(enc_idx_buffers, int, 0644);
1c1e45d1
HV		 122module_param(enc_yuv_buffers, int, 0644);
123module_param(enc_vbi_buffers, int, 0644);
124module_param(enc_pcm_buffers, int, 0644);
125
6ecd86dc
AW		 126module_param(enc_ts_bufsize, int, 0644);
127module_param(enc_mpg_bufsize, int, 0644);
128module_param(enc_idx_bufsize, int, 0644);
129module_param(enc_yuv_bufsize, int, 0644);
6ecd86dc
AW		 130module_param(enc_pcm_bufsize, int, 0644);
131
132module_param(enc_ts_bufs, int, 0644);
133module_param(enc_mpg_bufs, int, 0644);
134module_param(enc_idx_bufs, int, 0644);
135module_param(enc_yuv_bufs, int, 0644);
136module_param(enc_vbi_bufs, int, 0644);
137module_param(enc_pcm_bufs, int, 0644);
138
1c1e45d1
HV		 139MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
140 "\t\t\tsee tuner.h for values");
141MODULE_PARM_DESC(radio,
142 "Enable or disable the radio. Use only if autodetection\n"
143 "\t\t\tfails. 0 = disable, 1 = enable");
144MODULE_PARM_DESC(cardtype,
145 "Only use this option if your card is not detected properly.\n"
146 "\t\tSpecify card type:\n"
147 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
148 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
149 "\t\t\t 3 = Compro VideoMate H900\n"
150 "\t\t\t 4 = Yuan MPC718\n"
03c28085 151 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
9eee4fb6 152 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
9d5af862
AW		 153 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
154 "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
1c1e45d1
HV		 155 "\t\t\t 0 = Autodetect (default)\n"
156 "\t\t\t-1 = Ignore this card\n\t\t");
157MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
158MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
159MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
160MODULE_PARM_DESC(debug,
161 "Debug level (bitmask). Default: 0\n"
162 "\t\t\t 1/0x0001: warning\n"
163 "\t\t\t 2/0x0002: info\n"
164 "\t\t\t 4/0x0004: mailbox\n"
165 "\t\t\t 8/0x0008: dma\n"
166 "\t\t\t 16/0x0010: ioctl\n"
167 "\t\t\t 32/0x0020: file\n"
168 "\t\t\t 64/0x0040: i2c\n"
169 "\t\t\t128/0x0080: irq\n"
170 "\t\t\t256/0x0100: high volume\n");
171MODULE_PARM_DESC(cx18_pci_latency,
172 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
173 "\t\t\tDefault: Yes");
d267d851 174MODULE_PARM_DESC(retry_mmio,
3f75c616
AW		 175 "(Deprecated) MMIO writes are now always checked and retried\n"
176 "\t\t\tEffectively: 1 [Yes]");
c641d09c 177MODULE_PARM_DESC(mmio_ndelay,
3f75c616
AW		 178 "(Deprecated) MMIO accesses are now never purposely delayed\n"
179 "\t\t\tEffectively: 0 ns");
1c1e45d1 180MODULE_PARM_DESC(enc_ts_buffers,
6ecd86dc 181 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
1c1e45d1 182 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
6ecd86dc
AW		 183MODULE_PARM_DESC(enc_ts_bufsize,
184 "Size of an encoder TS buffer (kB)\n"
185 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
186MODULE_PARM_DESC(enc_ts_bufs,
187 "Number of encoder TS buffers\n"
188 "\t\t\tDefault is computed from other enc_ts_* parameters");
189MODULE_PARM_DESC(enc_mpg_buffers,
190 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
191 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
192MODULE_PARM_DESC(enc_mpg_bufsize,
193 "Size of an encoder MPG buffer (kB)\n"
194 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
195MODULE_PARM_DESC(enc_mpg_bufs,
196 "Number of encoder MPG buffers\n"
197 "\t\t\tDefault is computed from other enc_mpg_* parameters");
198MODULE_PARM_DESC(enc_idx_buffers,
199 "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
200 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS));
201MODULE_PARM_DESC(enc_idx_bufsize,
202 "Size of an encoder IDX buffer (kB)\n"
203 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
204MODULE_PARM_DESC(enc_idx_bufs,
205 "Number of encoder IDX buffers\n"
206 "\t\t\tDefault is computed from other enc_idx_* parameters");
1c1e45d1 207MODULE_PARM_DESC(enc_yuv_buffers,
6ecd86dc 208 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
1c1e45d1 209 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
6ecd86dc
AW		 210MODULE_PARM_DESC(enc_yuv_bufsize,
211 "Size of an encoder YUV buffer (kB)\n"
22dce188
AW		 212 "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
213 "\t\t\t(multiples of size required for 32 screen lines)\n"
214 "\t\t\tDefault: 102");
6ecd86dc
AW		 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"
127ce5f0 223 "\t\t\tDefault is computed from enc_vbi_buffers");
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 501 /*
22dce188
AW		 502 * YUV is a special case where the stream_buf_size needs to be
503 * an integral multiple of 33.75 kB (storage for 32 screens
504 * lines to maintain alignment in case of lost buffers
505 */
506 if (i == CX18_ENC_STREAM_TYPE_YUV) {
507 cx->stream_buf_size[i] *= 1024;
508 cx->stream_buf_size[i] -=
509 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
510
511 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
512 cx->stream_buf_size[i] =
513 CX18_UNIT_ENC_YUV_BUFSIZE;
514 }
515 /*
516 * YUV is a special case where the stream_buf_size is
517 * now in bytes.
466df464
AW		 518 * VBI is a special case where the stream_buf_size is fixed
519 * and already in bytes
520 */
22dce188
AW		 521 if (i == CX18_ENC_STREAM_TYPE_VBI ||
522 i == CX18_ENC_STREAM_TYPE_YUV) {
466df464
AW		 523 if (cx->stream_buffers[i] < 0) {
524 cx->stream_buffers[i] =
525 cx->options.megabytes[i] * 1024 * 1024
526 / cx->stream_buf_size[i];
527 } else {
528 /* N.B. This might round down to 0 */
529 cx->options.megabytes[i] =
530 cx->stream_buffers[i]
531 * cx->stream_buf_size[i]/(1024 * 1024);
6ecd86dc 532 }
6ecd86dc 533 } else {
22dce188
AW		 534 /* All other streams have stream_buf_size in kB here */
535 if (cx->stream_buffers[i] < 0) {
536 cx->stream_buffers[i] =
537 cx->options.megabytes[i] * 1024
538 / cx->stream_buf_size[i];
539 } else {
540 /* N.B. This might round down to 0 */
541 cx->options.megabytes[i] =
542 cx->stream_buffers[i]
543 * cx->stream_buf_size[i] / 1024;
544 }
545 /* convert from kB to bytes */
546 cx->stream_buf_size[i] *= 1024;
6ecd86dc 547 }
22dce188
AW		 548 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
549 "%d bytes\n", i, cx->options.megabytes[i],
550 cx->stream_buffers[i], cx->stream_buf_size[i]);
6ecd86dc
AW		 551 }
552
5811cf99
AW		 553 cx->options.cardtype = cardtype[cx->instance];
554 cx->options.tuner = tuner[cx->instance];
555 cx->options.radio = radio[cx->instance];
1c1e45d1
HV		 556
557 cx->std = cx18_parse_std(cx);
558 if (cx->options.cardtype == -1) {
559 CX18_INFO("Ignore card\n");
560 return;
561 }
562 cx->card = cx18_get_card(cx->options.cardtype - 1);
563 if (cx->card)
564 CX18_INFO("User specified %s card\n", cx->card->name);
565 else if (cx->options.cardtype != 0)
566 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
567 if (cx->card == NULL) {
3d05913d 568 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
1c1e45d1
HV		 569 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
570 CX18_INFO("Autodetected Hauppauge card\n");
571 }
572 }
573 if (cx->card == NULL) {
574 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
575 if (cx->card->pci_list == NULL)
576 continue;
577 for (j = 0; cx->card->pci_list[j].device; j++) {
3d05913d 578 if (cx->pci_dev->device !=
1c1e45d1
HV		 579 cx->card->pci_list[j].device)
580 continue;
3d05913d 581 if (cx->pci_dev->subsystem_vendor !=
1c1e45d1
HV		 582 cx->card->pci_list[j].subsystem_vendor)
583 continue;
3d05913d 584 if (cx->pci_dev->subsystem_device !=
1c1e45d1
HV		 585 cx->card->pci_list[j].subsystem_device)
586 continue;
587 CX18_INFO("Autodetected %s card\n", cx->card->name);
588 goto done;
589 }
590 }
591 }
592done:
593
594 if (cx->card == NULL) {
595 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
29e66a6c 596 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
3d05913d 597 cx->pci_dev->vendor, cx->pci_dev->device);
29e66a6c 598 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
3d05913d
AW		 599 cx->pci_dev->subsystem_vendor,
600 cx->pci_dev->subsystem_device);
1c1e45d1
HV		 601 CX18_ERR("Defaulting to %s card\n", cx->card->name);
602 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
603 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
604 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
605 }
606 cx->v4l2_cap = cx->card->v4l2_capabilities;
607 cx->card_name = cx->card->name;
608 cx->card_i2c = cx->card->i2c;
609}
610
87116159
AW		 611static int __devinit cx18_create_in_workq(struct cx18 *cx)
612{
613 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
614 cx->v4l2_dev.name);
615 cx->in_work_queue = create_singlethread_workqueue(cx->in_workq_name);
616 if (cx->in_work_queue == NULL) {
617 CX18_ERR("Unable to create incoming mailbox handler thread\n");
618 return -ENOMEM;
619 }
620 return 0;
621}
622
623static int __devinit cx18_create_out_workq(struct cx18 *cx)
624{
625 snprintf(cx->out_workq_name, sizeof(cx->out_workq_name), "%s-out",
626 cx->v4l2_dev.name);
627 cx->out_work_queue = create_workqueue(cx->out_workq_name);
628 if (cx->out_work_queue == NULL) {
629 CX18_ERR("Unable to create outgoing mailbox handler threads\n");
630 return -ENOMEM;
631 }
632 return 0;
633}
634
635static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
636{
637 int i;
638 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
639 cx->in_work_order[i].cx = cx;
640 cx->in_work_order[i].str = cx->epu_debug_str;
641 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
642 }
643}
644
1c1e45d1 645/* Precondition: the cx18 structure has been memset to 0. Only
5811cf99 646 the dev and instance fields have been filled in.
1c1e45d1
HV		 647 No assumptions on the card type may be made here (see cx18_init_struct2
648 for that).
649 */
650static int __devinit cx18_init_struct1(struct cx18 *cx)
651{
87116159 652 int ret;
ee2d64f5 653
3d05913d 654 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
1c1e45d1
HV		 655
656 mutex_init(&cx->serialize_lock);
8abdd00d 657 mutex_init(&cx->gpio_lock);
72c2d6d3
AW		 658 mutex_init(&cx->epu2apu_mb_lock);
659 mutex_init(&cx->epu2cpu_mb_lock);
1c1e45d1 660
87116159
AW		 661 ret = cx18_create_out_workq(cx);
662 if (ret)
663 return ret;
572bfea7 664
87116159
AW		 665 ret = cx18_create_in_workq(cx);
666 if (ret) {
667 destroy_workqueue(cx->out_work_queue);
668 return ret;
ee2d64f5 669 }
1d6782bd 670
87116159
AW		 671 cx18_init_in_work_orders(cx);
672
1c1e45d1
HV		 673 /* start counting open_id at 1 */
674 cx->open_id = 1;
675
676 /* Initial settings */
677 cx2341x_fill_defaults(&cx->params);
678 cx->temporal_strength = cx->params.video_temporal_filter;
679 cx->spatial_strength = cx->params.video_spatial_filter;
680 cx->filter_mode = cx->params.video_spatial_filter_mode |
681 (cx->params.video_temporal_filter_mode << 1) |
682 (cx->params.video_median_filter_type << 2);
683 cx->params.port = CX2341X_PORT_MEMORY;
302df970 684 cx->params.capabilities =
006e7179 685 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
1c1e45d1
HV		 686 init_waitqueue_head(&cx->cap_w);
687 init_waitqueue_head(&cx->mb_apu_waitq);
688 init_waitqueue_head(&cx->mb_cpu_waitq);
1c1e45d1
HV		 689 init_waitqueue_head(&cx->dma_waitq);
690
691 /* VBI */
dd073434 692 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
1c1e45d1 693 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
af009cf6 694
52fcb3ec
AW		 695 /* IVTV style VBI insertion into MPEG streams */
696 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
697 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
698 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
699 list_add(&cx->vbi.sliced_mpeg_buf.list,
700 &cx->vbi.sliced_mpeg_mdl.buf_list);
1c1e45d1
HV		 701 return 0;
702}
703
704/* Second initialization part. Here the card type has been
705 autodetected. */
706static void __devinit cx18_init_struct2(struct cx18 *cx)
707{
708 int i;
709
710 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
711 if (cx->card->video_inputs[i].video_type == 0)
712 break;
713 cx->nof_inputs = i;
714 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
715 if (cx->card->audio_inputs[i].audio_type == 0)
716 break;
717 cx->nof_audio_inputs = i;
718
719 /* Find tuner input */
720 for (i = 0; i < cx->nof_inputs; i++) {
721 if (cx->card->video_inputs[i].video_type ==
722 CX18_CARD_INPUT_VID_TUNER)
723 break;
724 }
725 if (i == cx->nof_inputs)
726 i = 0;
727 cx->active_input = i;
728 cx->audio_input = cx->card->video_inputs[i].audio_index;
1c1e45d1
HV		 729}
730
3d05913d 731static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
1c1e45d1
HV		 732 const struct pci_device_id *pci_id)
733{
734 u16 cmd;
735 unsigned char pci_latency;
736
737 CX18_DEBUG_INFO("Enabling pci device\n");
738
3d05913d 739 if (pci_enable_device(pci_dev)) {
5811cf99 740 CX18_ERR("Can't enable device %d!\n", cx->instance);
1c1e45d1
HV		 741 return -EIO;
742 }
3d05913d 743 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
5811cf99 744 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
1c1e45d1
HV		 745 return -EIO;
746 }
747 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
5811cf99
AW		 748 CX18_ERR("Cannot request encoder memory region, card %d\n",
749 cx->instance);
1c1e45d1
HV		 750 return -EIO;
751 }
752
4519064c 753 /* Enable bus mastering and memory mapped IO for the CX23418 */
3d05913d 754 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
4519064c 755 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
3d05913d 756 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
1c1e45d1 757
3d05913d
AW		 758 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
759 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
1c1e45d1
HV		 760
761 if (pci_latency < 64 && cx18_pci_latency) {
762 CX18_INFO("Unreasonably low latency timer, "
763 "setting to 64 (was %d)\n", pci_latency);
3d05913d
AW		 764 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
765 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
1c1e45d1 766 }
1c1e45d1
HV		 767
768 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
769 "irq: %d, latency: %d, memory: 0x%lx\n",
3d05913d
AW		 770 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
771 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
772 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
1c1e45d1
HV		 773
774 return 0;
775}
776
ff2a2001 777static void cx18_init_subdevs(struct cx18 *cx)
1c1e45d1
HV		 778{
779 u32 hw = cx->card->hw_all;
ff2a2001 780 u32 device;
1c1e45d1
HV		 781 int i;
782
ff2a2001 783 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
1c1e45d1
HV		 784
785 if (!(device & hw))
786 continue;
ff2a2001
AW		 787
788 switch (device) {
ff2a2001
AW		 789 case CX18_HW_DVB:
790 case CX18_HW_TVEEPROM:
791 /* These subordinate devices do not use probing */
1c1e45d1 792 cx->hw_flags |= device;
ff2a2001
AW		 793 break;
794 case CX18_HW_418_AV:
795 /* The A/V decoder gets probed earlier to set PLLs */
796 /* Just note that the card uses it (i.e. has analog) */
1c1e45d1 797 cx->hw_flags |= device;
ff2a2001 798 break;
eefe1010
AW		 799 case CX18_HW_GPIO_RESET_CTRL:
800 /*
801 * The Reset Controller gets probed and added to
802 * hw_flags earlier for i2c adapter/bus initialization
803 */
804 break;
805 case CX18_HW_GPIO_MUX:
806 if (cx18_gpio_register(cx, device) == 0)
807 cx->hw_flags |= device;
808 break;
ff2a2001
AW		 809 default:
810 if (cx18_i2c_register(cx, i) == 0)
811 cx->hw_flags |= device;
812 break;
813 }
1c1e45d1
HV		 814 }
815
ff2a2001
AW		 816 if (cx->hw_flags & CX18_HW_418_AV)
817 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
818
819 if (cx->card->hw_muxer != 0)
820 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
1c1e45d1
HV		 821}
822
3d05913d 823static int __devinit cx18_probe(struct pci_dev *pci_dev,
1c1e45d1
HV		 824 const struct pci_device_id *pci_id)
825{
826 int retval = 0;
ff086575 827 int i;
1c1e45d1
HV		 828 u32 devtype;
829 struct cx18 *cx;
830
5811cf99
AW		 831 /* FIXME - module parameter arrays constrain max instances */
832 i = atomic_inc_return(&cx18_instance) - 1;
833 if (i >= CX18_MAX_CARDS) {
834 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
835 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
1c1e45d1
HV		 836 return -ENOMEM;
837 }
838
839 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
5811cf99
AW		 840 if (cx == NULL) {
841 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
842 i);
1c1e45d1
HV		 843 return -ENOMEM;
844 }
888cdb07 845 cx->pci_dev = pci_dev;
5811cf99
AW		 846 cx->instance = i;
847
888cdb07
AW		 848 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
849 if (retval) {
5811cf99
AW		 850 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
851 "\n", cx->instance);
852 kfree(cx);
853 return retval;
888cdb07 854 }
5811cf99
AW		 855 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
856 cx->instance);
857 CX18_INFO("Initializing card %d\n", cx->instance);
888cdb07 858
1c1e45d1
HV		 859 cx18_process_options(cx);
860 if (cx->options.cardtype == -1) {
861 retval = -ENODEV;
5811cf99 862 goto err;
1c1e45d1 863 }
87116159
AW		 864
865 retval = cx18_init_struct1(cx);
866 if (retval)
5811cf99 867 goto err;
1c1e45d1
HV		 868
869 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
870
871 /* PCI Device Setup */
3d05913d 872 retval = cx18_setup_pci(cx, pci_dev, pci_id);
572bfea7 873 if (retval != 0)
87116159 874 goto free_workqueues;
572bfea7 875
1c1e45d1
HV		 876 /* map io memory */
877 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
878 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
879 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
880 CX18_MEM_SIZE);
881 if (!cx->enc_mem) {
882 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
883 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
884 retval = -ENOMEM;
885 goto free_mem;
886 }
887 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
b1526421 888 devtype = cx18_read_reg(cx, 0xC72028);
1c1e45d1
HV		 889 switch (devtype & 0xff000000) {
890 case 0xff000000:
891 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
892 break;
893 case 0x01000000:
894 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
895 break;
896 default:
897 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
898 break;
899 }
900
901 cx18_init_power(cx, 1);
902 cx18_init_memory(cx);
903
990c81c8 904 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
1c1e45d1
HV		 905 cx18_init_scb(cx);
906
907 cx18_gpio_init(cx);
908
ff2a2001
AW		 909 /* Initialize integrated A/V decoder early to set PLLs, just in case */
910 retval = cx18_av_probe(cx);
fa3e7036
AW		 911 if (retval) {
912 CX18_ERR("Could not register A/V decoder subdevice\n");
913 goto free_map;
914 }
fa3e7036 915
eefe1010
AW		 916 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
917 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
918 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
919 CX18_WARN("Could not register GPIO reset controller"
920 "subdevice; proceeding anyway.\n");
921 else
922 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
923 }
924
1c1e45d1
HV		 925 /* active i2c */
926 CX18_DEBUG_INFO("activating i2c...\n");
9b4a7c8a
AW		 927 retval = init_cx18_i2c(cx);
928 if (retval) {
1c1e45d1
HV		 929 CX18_ERR("Could not initialize i2c\n");
930 goto free_map;
931 }
932
1c1e45d1
HV		 933 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
934 /* Based on the model number the cardtype may be changed.
935 The PCI IDs are not always reliable. */
936 cx18_process_eeprom(cx);
937 }
938 if (cx->card->comment)
939 CX18_INFO("%s", cx->card->comment);
940 if (cx->card->v4l2_capabilities == 0) {
941 retval = -ENODEV;
942 goto free_i2c;
943 }
944 cx18_init_memory(cx);
fd6b9c97 945 cx18_init_scb(cx);
1c1e45d1
HV		 946
947 /* Register IRQ */
3d05913d 948 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
5811cf99
AW		 949 IRQF_SHARED | IRQF_DISABLED,
950 cx->v4l2_dev.name, (void *)cx);
1c1e45d1
HV		 951 if (retval) {
952 CX18_ERR("Failed to register irq %d\n", retval);
953 goto free_i2c;
954 }
955
956 if (cx->std == 0)
957 cx->std = V4L2_STD_NTSC_M;
958
959 if (cx->options.tuner == -1) {
1c1e45d1
HV		 960 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
961 if ((cx->std & cx->card->tuners[i].std) == 0)
962 continue;
963 cx->options.tuner = cx->card->tuners[i].tuner;
964 break;
965 }
966 }
967 /* if no tuner was found, then pick the first tuner in the card list */
968 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
969 cx->std = cx->card->tuners[0].std;
c3cb4d95
HV		 970 if (cx->std & V4L2_STD_PAL)
971 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
972 else if (cx->std & V4L2_STD_NTSC)
973 cx->std = V4L2_STD_NTSC_M;
974 else if (cx->std & V4L2_STD_SECAM)
975 cx->std = V4L2_STD_SECAM_L;
1c1e45d1
HV		 976 cx->options.tuner = cx->card->tuners[0].tuner;
977 }
978 if (cx->options.radio == -1)
979 cx->options.radio = (cx->card->radio_input.audio_type != 0);
980
981 /* The card is now fully identified, continue with card-specific
982 initialization. */
983 cx18_init_struct2(cx);
984
ff2a2001 985 cx18_init_subdevs(cx);
1c1e45d1 986
8d037ed1 987 if (cx->std & V4L2_STD_525_60)
1c1e45d1 988 cx->is_60hz = 1;
8d037ed1 989 else
1c1e45d1 990 cx->is_50hz = 1;
8d037ed1 991
1c1e45d1
HV		 992 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
993
1c1e45d1
HV		 994 if (cx->options.radio > 0)
995 cx->v4l2_cap |= V4L2_CAP_RADIO;
996
1c1e45d1
HV		 997 if (cx->options.tuner > -1) {
998 struct tuner_setup setup;
999
1000 setup.addr = ADDR_UNSET;
1001 setup.type = cx->options.tuner;
1002 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1003 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1004 cx18_reset_tuner_gpio : NULL;
ff2a2001 1005 cx18_call_all(cx, tuner, s_type_addr, &setup);
1c1e45d1
HV		 1006 if (setup.type == TUNER_XC2028) {
1007 static struct xc2028_ctrl ctrl = {
1008 .fname = XC2028_DEFAULT_FIRMWARE,
1009 .max_len = 64,
1010 };
1011 struct v4l2_priv_tun_config cfg = {
1012 .tuner = cx->options.tuner,
1013 .priv = &ctrl,
1014 };
ff2a2001 1015 cx18_call_all(cx, tuner, s_config, &cfg);
1c1e45d1
HV		 1016 }
1017 }
1018
1019 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1020 are not. */
1021 cx->tuner_std = cx->std;
1022
5e7fdc5e
HV		 1023 retval = cx18_streams_setup(cx);
1024 if (retval) {
1025 CX18_ERR("Error %d setting up streams\n", retval);
1026 goto free_irq;
1027 }
1028 retval = cx18_streams_register(cx);
1029 if (retval) {
1030 CX18_ERR("Error %d registering devices\n", retval);
1031 goto free_streams;
1032 }
1c1e45d1 1033
5811cf99 1034 CX18_INFO("Initialized card: %s\n", cx->card_name);
1c1e45d1
HV		 1035 return 0;
1036
1037free_streams:
3f98387e 1038 cx18_streams_cleanup(cx, 1);
1c1e45d1 1039free_irq:
3d05913d 1040 free_irq(cx->pci_dev->irq, (void *)cx);
1c1e45d1
HV		 1041free_i2c:
1042 exit_cx18_i2c(cx);
1043free_map:
1044 cx18_iounmap(cx);
1045free_mem:
1046 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
87116159 1047free_workqueues:
deed75ed 1048 destroy_workqueue(cx->in_work_queue);
87116159 1049 destroy_workqueue(cx->out_work_queue);
1c1e45d1
HV		 1050err:
1051 if (retval == 0)
1052 retval = -ENODEV;
1053 CX18_ERR("Error %d on initialization\n", retval);
1054
5811cf99
AW		 1055 v4l2_device_unregister(&cx->v4l2_dev);
1056 kfree(cx);
1c1e45d1
HV		 1057 return retval;
1058}
1059
1060int cx18_init_on_first_open(struct cx18 *cx)
1061{
1062 int video_input;
1063 int fw_retry_count = 3;
1064 struct v4l2_frequency vf;
3b6fe58f
AW		 1065 struct cx18_open_id fh;
1066
1067 fh.cx = cx;
1c1e45d1
HV		 1068
1069 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1070 return -ENXIO;
1071
1072 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1073 return 0;
1074
1075 while (--fw_retry_count > 0) {
1076 /* load firmware */
1077 if (cx18_firmware_init(cx) == 0)
1078 break;
1079 if (fw_retry_count > 1)
1080 CX18_WARN("Retry loading firmware\n");
1081 }
1082
1083 if (fw_retry_count == 0) {
1084 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1085 return -ENXIO;
1086 }
1087 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1088
350145a4
AW		 1089 /*
1090 * Init the firmware twice to work around a silicon bug
1091 * with the digital TS.
1092 *
1093 * The second firmware load requires us to normalize the APU state,
1094 * or the audio for the first analog capture will be badly incorrect.
1095 *
1096 * I can't seem to call APU_RESETAI and have it succeed without the
1097 * APU capturing audio, so we start and stop it here to do the reset
1098 */
1099
1100 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1101 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1102 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1103 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1c1e45d1
HV		 1104
1105 fw_retry_count = 3;
1106 while (--fw_retry_count > 0) {
1107 /* load firmware */
1108 if (cx18_firmware_init(cx) == 0)
1109 break;
1110 if (fw_retry_count > 1)
1111 CX18_WARN("Retry loading firmware\n");
1112 }
1113
1114 if (fw_retry_count == 0) {
1115 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1116 return -ENXIO;
1117 }
1118
d5c02f6b
AW		 1119 /*
1120 * The second firmware load requires us to normalize the APU state,
1121 * or the audio for the first analog capture will be badly incorrect.
1122 *
1123 * I can't seem to call APU_RESETAI and have it succeed without the
1124 * APU capturing audio, so we start and stop it here to do the reset
1125 */
1126
1127 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1128 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1129 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1130 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1131
fa3e7036 1132 /* Init the A/V decoder, if it hasn't been already */
cc26b076 1133 v4l2_subdev_call(cx->sd_av, core, load_fw);
fa3e7036 1134
1c1e45d1
HV		 1135 vf.tuner = 0;
1136 vf.type = V4L2_TUNER_ANALOG_TV;
1137 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1138
1139 /* Set initial frequency. For PAL/SECAM broadcasts no
1140 'default' channel exists AFAIK. */
1141 if (cx->std == V4L2_STD_NTSC_M_JP)
1142 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1143 else if (cx->std & V4L2_STD_NTSC_M)
1144 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1145
1146 video_input = cx->active_input;
1147 cx->active_input++; /* Force update of input */
3b6fe58f 1148 cx18_s_input(NULL, &fh, video_input);
1c1e45d1
HV		 1149
1150 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1151 in one place. */
1152 cx->std++; /* Force full standard initialization */
3b6fe58f
AW		 1153 cx18_s_std(NULL, &fh, &cx->tuner_std);
1154 cx18_s_frequency(NULL, &fh, &vf);
1c1e45d1
HV		 1155 return 0;
1156}
1157
deed75ed 1158static void cx18_cancel_in_work_orders(struct cx18 *cx)
18b5dc2e
AW		 1159{
1160 int i;
deed75ed
AW		 1161 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1162 cancel_work_sync(&cx->in_work_order[i].work);
18b5dc2e
AW		 1163}
1164
21a278b8
AW		 1165static void cx18_cancel_out_work_orders(struct cx18 *cx)
1166{
1167 int i;
1168 for (i = 0; i < CX18_MAX_STREAMS; i++)
1169 if (&cx->streams[i].video_dev != NULL)
1170 cancel_work_sync(&cx->streams[i].out_work_order);
1171}
1172
1c1e45d1
HV		 1173static void cx18_remove(struct pci_dev *pci_dev)
1174{
888cdb07 1175 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
5811cf99 1176 struct cx18 *cx = to_cx18(v4l2_dev);
6da6bf5e 1177 int i;
1c1e45d1 1178
5811cf99 1179 CX18_DEBUG_INFO("Removing Card\n");
1c1e45d1
HV		 1180
1181 /* Stop all captures */
1182 CX18_DEBUG_INFO("Stopping all streams\n");
31554ae5 1183 if (atomic_read(&cx->tot_capturing) > 0)
1c1e45d1
HV		 1184 cx18_stop_all_captures(cx);
1185
87116159 1186 /* Stop interrupts that cause incoming work to be queued */
b1526421 1187 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
87116159
AW		 1188
1189 /* Incoming work can cause outgoing work, so clean up incoming first */
1190 cx18_cancel_in_work_orders(cx);
21a278b8 1191 cx18_cancel_out_work_orders(cx);
87116159
AW		 1192
1193 /* Stop ack interrupts that may have been needed for work to finish */
b1526421 1194 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1c1e45d1
HV		 1195
1196 cx18_halt_firmware(cx);
1197
deed75ed 1198 destroy_workqueue(cx->in_work_queue);
87116159 1199 destroy_workqueue(cx->out_work_queue);
572bfea7 1200
3f98387e 1201 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 1202
1203 exit_cx18_i2c(cx);
1204
3d05913d 1205 free_irq(cx->pci_dev->irq, (void *)cx);
1c1e45d1 1206
cba627a5 1207 cx18_iounmap(cx);
1c1e45d1
HV		 1208
1209 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1210
3d05913d 1211 pci_disable_device(cx->pci_dev);
6da6bf5e
AW		 1212
1213 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1214 for (i = 0; i < CX18_VBI_FRAMES; i++)
1215 kfree(cx->vbi.sliced_mpeg_data[i]);
1c1e45d1 1216
5811cf99 1217 CX18_INFO("Removed %s\n", cx->card_name);
888cdb07 1218
5811cf99
AW		 1219 v4l2_device_unregister(v4l2_dev);
1220 kfree(cx);
1c1e45d1
HV		 1221}
1222
1223/* define a pci_driver for card detection */
1224static struct pci_driver cx18_pci_driver = {
1225 .name = "cx18",
1226 .id_table = cx18_pci_tbl,
1227 .probe = cx18_probe,
1228 .remove = cx18_remove,
1229};
1230
9710e7a7 1231static int __init module_start(void)
1c1e45d1
HV		 1232{
1233 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1234
1c1e45d1
HV		 1235 /* Validate parameters */
1236 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
dd89601d 1237 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1c1e45d1
HV		 1238 CX18_MAX_CARDS - 1);
1239 return -1;
1240 }
1241
1242 if (cx18_debug < 0 || cx18_debug > 511) {
1243 cx18_debug = 0;
1244 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1245 }
1246
1247 if (pci_register_driver(&cx18_pci_driver)) {
1248 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1249 return -ENODEV;
1250 }
1251 printk(KERN_INFO "cx18: End initialization\n");
1252 return 0;
1253}
1254
9710e7a7 1255static void __exit module_cleanup(void)
1c1e45d1 1256{
1c1e45d1 1257 pci_unregister_driver(&cx18_pci_driver);
1c1e45d1
HV		 1258}
1259
1260module_init(module_start);
1261module_exit(module_cleanup);
Linux 6.x block layer and io_uring tree(s)