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