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