projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'x86/ptrace' into x86/tsc
[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>
c641d09c 7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
1c1e45d1
HV		 8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 * 02111-1307 USA
23 */
24
25#include "cx18-driver.h"
b1526421 26#include "cx18-io.h"
1c1e45d1
HV		 27#include "cx18-version.h"
28#include "cx18-cards.h"
29#include "cx18-i2c.h"
30#include "cx18-irq.h"
31#include "cx18-gpio.h"
32#include "cx18-firmware.h"
33#include "cx18-streams.h"
34#include "cx18-av-core.h"
35#include "cx18-scb.h"
36#include "cx18-mailbox.h"
37#include "cx18-ioctl.h"
38#include "tuner-xc2028.h"
39
40#include <media/tveeprom.h>
41
42
43/* var to keep track of the number of array elements in use */
44int cx18_cards_active;
45
46/* If you have already X v4l cards, then set this to X. This way
47 the device numbers stay matched. Example: you have a WinTV card
48 without radio and a Compro H900 with. Normally this would give a
49 video1 device together with a radio0 device for the Compro. By
50 setting this to 1 you ensure that radio0 is now also radio1. */
51int cx18_first_minor;
52
53/* Master variable for all cx18 info */
54struct cx18 *cx18_cards[CX18_MAX_CARDS];
55
56/* Protects cx18_cards_active */
57DEFINE_SPINLOCK(cx18_cards_lock);
58
59/* add your revision and whatnot here */
60static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
61 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
62 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
63 {0,}
64};
65
66MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
67
68/* Parameter declarations */
69static int cardtype[CX18_MAX_CARDS];
70static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
71 -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 };
74static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1,
76 -1, -1, -1, -1, -1, -1, -1, -1,
77 -1, -1, -1, -1, -1, -1, -1, -1 };
c641d09c
AW		 78static int mmio_ndelay[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
79 -1, -1, -1, -1, -1, -1, -1, -1,
80 -1, -1, -1, -1, -1, -1, -1, -1,
81 -1, -1, -1, -1, -1, -1, -1, -1 };
c6eb8eaf
HV		 82static unsigned cardtype_c = 1;
83static unsigned tuner_c = 1;
84static unsigned radio_c = 1;
2796073a 85static unsigned mmio_ndelay_c = 1;
1c1e45d1
HV		 86static char pal[] = "--";
87static char secam[] = "--";
88static char ntsc[] = "-";
89
90/* Buffers */
91static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
92static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
93static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
94static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
95static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
96
97static int cx18_pci_latency = 1;
98
d267d851 99int cx18_retry_mmio = 1;
1c1e45d1
HV		 100int cx18_debug;
101
102module_param_array(tuner, int, &tuner_c, 0644);
103module_param_array(radio, bool, &radio_c, 0644);
104module_param_array(cardtype, int, &cardtype_c, 0644);
c641d09c 105module_param_array(mmio_ndelay, int, &mmio_ndelay_c, 0644);
1c1e45d1
HV		 106module_param_string(pal, pal, sizeof(pal), 0644);
107module_param_string(secam, secam, sizeof(secam), 0644);
108module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
109module_param_named(debug, cx18_debug, int, 0644);
d267d851 110module_param_named(retry_mmio, cx18_retry_mmio, int, 0644);
1c1e45d1
HV		 111module_param(cx18_pci_latency, int, 0644);
112module_param(cx18_first_minor, int, 0644);
113
114module_param(enc_mpg_buffers, int, 0644);
115module_param(enc_ts_buffers, int, 0644);
116module_param(enc_yuv_buffers, int, 0644);
117module_param(enc_vbi_buffers, int, 0644);
118module_param(enc_pcm_buffers, int, 0644);
119
120MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
121 "\t\t\tsee tuner.h for values");
122MODULE_PARM_DESC(radio,
123 "Enable or disable the radio. Use only if autodetection\n"
124 "\t\t\tfails. 0 = disable, 1 = enable");
125MODULE_PARM_DESC(cardtype,
126 "Only use this option if your card is not detected properly.\n"
127 "\t\tSpecify card type:\n"
128 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
129 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
130 "\t\t\t 3 = Compro VideoMate H900\n"
131 "\t\t\t 4 = Yuan MPC718\n"
03c28085 132 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
9eee4fb6
AW		 133 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
134 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
1c1e45d1
HV		 135 "\t\t\t 0 = Autodetect (default)\n"
136 "\t\t\t-1 = Ignore this card\n\t\t");
137MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
138MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
139MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
140MODULE_PARM_DESC(debug,
141 "Debug level (bitmask). Default: 0\n"
142 "\t\t\t 1/0x0001: warning\n"
143 "\t\t\t 2/0x0002: info\n"
144 "\t\t\t 4/0x0004: mailbox\n"
145 "\t\t\t 8/0x0008: dma\n"
146 "\t\t\t 16/0x0010: ioctl\n"
147 "\t\t\t 32/0x0020: file\n"
148 "\t\t\t 64/0x0040: i2c\n"
149 "\t\t\t128/0x0080: irq\n"
150 "\t\t\t256/0x0100: high volume\n");
151MODULE_PARM_DESC(cx18_pci_latency,
152 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
153 "\t\t\tDefault: Yes");
d267d851
AW		 154MODULE_PARM_DESC(retry_mmio,
155 "Check and retry memory mapped IO accesses\n"
156 "\t\t\tDefault: 1 [Yes]");
c641d09c
AW		 157MODULE_PARM_DESC(mmio_ndelay,
158 "Delay (ns) for each CX23418 memory mapped IO access.\n"
159 "\t\t\tTry larger values that are close to a multiple of the\n"
160 "\t\t\tPCI clock period, 30.3 ns, if your card doesn't work.\n"
161 "\t\t\tDefault: " __stringify(CX18_DEFAULT_MMIO_NDELAY));
1c1e45d1
HV		 162MODULE_PARM_DESC(enc_mpg_buffers,
163 "Encoder MPG Buffers (in MB)\n"
164 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
165MODULE_PARM_DESC(enc_ts_buffers,
166 "Encoder TS Buffers (in MB)\n"
167 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
168MODULE_PARM_DESC(enc_yuv_buffers,
169 "Encoder YUV Buffers (in MB)\n"
170 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
171MODULE_PARM_DESC(enc_vbi_buffers,
172 "Encoder VBI Buffers (in MB)\n"
173 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
174MODULE_PARM_DESC(enc_pcm_buffers,
175 "Encoder PCM buffers (in MB)\n"
176 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
177
dd89601d 178MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
1c1e45d1
HV		 179
180MODULE_AUTHOR("Hans Verkuil");
181MODULE_DESCRIPTION("CX23418 driver");
182MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
183MODULE_LICENSE("GPL");
184
185MODULE_VERSION(CX18_VERSION);
186
1c1e45d1
HV		 187/* Generic utility functions */
188int cx18_msleep_timeout(unsigned int msecs, int intr)
189{
190 int timeout = msecs_to_jiffies(msecs);
191 int sig;
192
193 do {
194 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
195 timeout = schedule_timeout(timeout);
196 sig = intr ? signal_pending(current) : 0;
197 } while (!sig && timeout);
198 return sig;
199}
200
201/* Release ioremapped memory */
202static void cx18_iounmap(struct cx18 *cx)
203{
204 if (cx == NULL)
205 return;
206
207 /* Release io memory */
208 if (cx->enc_mem != NULL) {
209 CX18_DEBUG_INFO("releasing enc_mem\n");
210 iounmap(cx->enc_mem);
211 cx->enc_mem = NULL;
212 }
213}
214
215/* Hauppauge card? get values from tveeprom */
216void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
217{
218 u8 eedata[256];
219
220 cx->i2c_client[0].addr = 0xA0 >> 1;
221 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
222 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
223}
224
225static void cx18_process_eeprom(struct cx18 *cx)
226{
227 struct tveeprom tv;
228
229 cx18_read_eeprom(cx, &tv);
230
231 /* Many thanks to Steven Toth from Hauppauge for providing the
232 model numbers */
1d081601
HV		 233 /* Note: the Samsung memory models cannot be reliably determined
234 from the model number. Use the cardtype module option if you
235 have one of these preproduction models. */
1c1e45d1 236 switch (tv.model) {
1d081601 237 case 74000 ... 74999:
1c1e45d1
HV		 238 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
239 break;
1c1e45d1
HV		 240 case 0:
241 CX18_ERR("Invalid EEPROM\n");
242 return;
243 default:
244 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
245 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
246 break;
247 }
248
249 cx->v4l2_cap = cx->card->v4l2_capabilities;
250 cx->card_name = cx->card->name;
251 cx->card_i2c = cx->card->i2c;
252
253 CX18_INFO("Autodetected %s\n", cx->card_name);
254
255 if (tv.tuner_type == TUNER_ABSENT)
256 CX18_ERR("tveeprom cannot autodetect tuner!");
257
258 if (cx->options.tuner == -1)
259 cx->options.tuner = tv.tuner_type;
260 if (cx->options.radio == -1)
261 cx->options.radio = (tv.has_radio != 0);
262
263 if (cx->std != 0)
264 /* user specified tuner standard */
265 return;
266
267 /* autodetect tuner standard */
268 if (tv.tuner_formats & V4L2_STD_PAL) {
269 CX18_DEBUG_INFO("PAL tuner detected\n");
270 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
271 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
272 CX18_DEBUG_INFO("NTSC tuner detected\n");
273 cx->std |= V4L2_STD_NTSC_M;
274 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
275 CX18_DEBUG_INFO("SECAM tuner detected\n");
276 cx->std |= V4L2_STD_SECAM_L;
277 } else {
278 CX18_INFO("No tuner detected, default to NTSC-M\n");
279 cx->std |= V4L2_STD_NTSC_M;
280 }
281}
282
283static v4l2_std_id cx18_parse_std(struct cx18 *cx)
284{
285 switch (pal[0]) {
286 case '6':
287 return V4L2_STD_PAL_60;
288 case 'b':
289 case 'B':
290 case 'g':
291 case 'G':
292 return V4L2_STD_PAL_BG;
293 case 'h':
294 case 'H':
295 return V4L2_STD_PAL_H;
296 case 'n':
297 case 'N':
298 if (pal[1] == 'c' || pal[1] == 'C')
299 return V4L2_STD_PAL_Nc;
300 return V4L2_STD_PAL_N;
301 case 'i':
302 case 'I':
303 return V4L2_STD_PAL_I;
304 case 'd':
305 case 'D':
306 case 'k':
307 case 'K':
308 return V4L2_STD_PAL_DK;
309 case 'M':
310 case 'm':
311 return V4L2_STD_PAL_M;
312 case '-':
313 break;
314 default:
315 CX18_WARN("pal= argument not recognised\n");
316 return 0;
317 }
318
319 switch (secam[0]) {
320 case 'b':
321 case 'B':
322 case 'g':
323 case 'G':
324 case 'h':
325 case 'H':
326 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
327 case 'd':
328 case 'D':
329 case 'k':
330 case 'K':
331 return V4L2_STD_SECAM_DK;
332 case 'l':
333 case 'L':
334 if (secam[1] == 'C' || secam[1] == 'c')
335 return V4L2_STD_SECAM_LC;
336 return V4L2_STD_SECAM_L;
337 case '-':
338 break;
339 default:
340 CX18_WARN("secam= argument not recognised\n");
341 return 0;
342 }
343
344 switch (ntsc[0]) {
345 case 'm':
346 case 'M':
347 return V4L2_STD_NTSC_M;
348 case 'j':
349 case 'J':
350 return V4L2_STD_NTSC_M_JP;
351 case 'k':
352 case 'K':
353 return V4L2_STD_NTSC_M_KR;
354 case '-':
355 break;
356 default:
357 CX18_WARN("ntsc= argument not recognised\n");
358 return 0;
359 }
360
361 /* no match found */
362 return 0;
363}
364
365static void cx18_process_options(struct cx18 *cx)
366{
367 int i, j;
368
369 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
370 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
371 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
372 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
373 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
374 cx->options.cardtype = cardtype[cx->num];
375 cx->options.tuner = tuner[cx->num];
376 cx->options.radio = radio[cx->num];
377
c641d09c
AW		 378 if (mmio_ndelay[cx->num] < 0)
379 cx->options.mmio_ndelay = CX18_DEFAULT_MMIO_NDELAY;
380 else
381 cx->options.mmio_ndelay = mmio_ndelay[cx->num];
382
1c1e45d1
HV		 383 cx->std = cx18_parse_std(cx);
384 if (cx->options.cardtype == -1) {
385 CX18_INFO("Ignore card\n");
386 return;
387 }
388 cx->card = cx18_get_card(cx->options.cardtype - 1);
389 if (cx->card)
390 CX18_INFO("User specified %s card\n", cx->card->name);
391 else if (cx->options.cardtype != 0)
392 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
393 if (cx->card == NULL) {
394 if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
395 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
396 CX18_INFO("Autodetected Hauppauge card\n");
397 }
398 }
399 if (cx->card == NULL) {
400 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
401 if (cx->card->pci_list == NULL)
402 continue;
403 for (j = 0; cx->card->pci_list[j].device; j++) {
404 if (cx->dev->device !=
405 cx->card->pci_list[j].device)
406 continue;
407 if (cx->dev->subsystem_vendor !=
408 cx->card->pci_list[j].subsystem_vendor)
409 continue;
410 if (cx->dev->subsystem_device !=
411 cx->card->pci_list[j].subsystem_device)
412 continue;
413 CX18_INFO("Autodetected %s card\n", cx->card->name);
414 goto done;
415 }
416 }
417 }
418done:
419
420 if (cx->card == NULL) {
421 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
29e66a6c 422 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
1c1e45d1 423 cx->dev->vendor, cx->dev->device);
29e66a6c 424 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
1c1e45d1
HV		 425 cx->dev->subsystem_vendor, cx->dev->subsystem_device);
426 CX18_ERR("Defaulting to %s card\n", cx->card->name);
427 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
428 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
429 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
430 }
431 cx->v4l2_cap = cx->card->v4l2_capabilities;
432 cx->card_name = cx->card->name;
433 cx->card_i2c = cx->card->i2c;
434}
435
436/* Precondition: the cx18 structure has been memset to 0. Only
437 the dev and num fields have been filled in.
438 No assumptions on the card type may be made here (see cx18_init_struct2
439 for that).
440 */
441static int __devinit cx18_init_struct1(struct cx18 *cx)
442{
443 cx->base_addr = pci_resource_start(cx->dev, 0);
444
445 mutex_init(&cx->serialize_lock);
446 mutex_init(&cx->i2c_bus_lock[0]);
447 mutex_init(&cx->i2c_bus_lock[1]);
8abdd00d 448 mutex_init(&cx->gpio_lock);
1c1e45d1
HV		 449
450 spin_lock_init(&cx->lock);
1c1e45d1 451
1d6782bd
AW		 452 cx->work_queue = create_singlethread_workqueue(cx->name);
453 if (cx->work_queue == NULL) {
454 CX18_ERR("Could not create work queue\n");
455 return -1;
456 }
457
458 INIT_WORK(&cx->work, cx18_work_handler);
459
1c1e45d1
HV		 460 /* start counting open_id at 1 */
461 cx->open_id = 1;
462
463 /* Initial settings */
464 cx2341x_fill_defaults(&cx->params);
465 cx->temporal_strength = cx->params.video_temporal_filter;
466 cx->spatial_strength = cx->params.video_spatial_filter;
467 cx->filter_mode = cx->params.video_spatial_filter_mode |
468 (cx->params.video_temporal_filter_mode << 1) |
469 (cx->params.video_median_filter_type << 2);
470 cx->params.port = CX2341X_PORT_MEMORY;
e8b934de 471 cx->params.capabilities = CX2341X_CAP_HAS_TS;
1c1e45d1
HV		 472 init_waitqueue_head(&cx->cap_w);
473 init_waitqueue_head(&cx->mb_apu_waitq);
474 init_waitqueue_head(&cx->mb_cpu_waitq);
475 init_waitqueue_head(&cx->mb_epu_waitq);
476 init_waitqueue_head(&cx->mb_hpu_waitq);
477 init_waitqueue_head(&cx->dma_waitq);
478
479 /* VBI */
480 cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
481 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
482 cx->vbi.raw_size = 1456;
483 cx->vbi.raw_decoder_line_size = 1456;
484 cx->vbi.raw_decoder_sav_odd_field = 0x20;
485 cx->vbi.raw_decoder_sav_even_field = 0x60;
486 cx->vbi.sliced_decoder_line_size = 272;
487 cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
488 cx->vbi.sliced_decoder_sav_even_field = 0xF0;
489 return 0;
490}
491
492/* Second initialization part. Here the card type has been
493 autodetected. */
494static void __devinit cx18_init_struct2(struct cx18 *cx)
495{
496 int i;
497
498 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
499 if (cx->card->video_inputs[i].video_type == 0)
500 break;
501 cx->nof_inputs = i;
502 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
503 if (cx->card->audio_inputs[i].audio_type == 0)
504 break;
505 cx->nof_audio_inputs = i;
506
507 /* Find tuner input */
508 for (i = 0; i < cx->nof_inputs; i++) {
509 if (cx->card->video_inputs[i].video_type ==
510 CX18_CARD_INPUT_VID_TUNER)
511 break;
512 }
513 if (i == cx->nof_inputs)
514 i = 0;
515 cx->active_input = i;
516 cx->audio_input = cx->card->video_inputs[i].audio_index;
517 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
518 cx->av_state.aud_input = CX18_AV_AUDIO8;
519 cx->av_state.audclk_freq = 48000;
520 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
521 cx->av_state.vbi_line_offset = 8;
522}
523
524static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
525 const struct pci_device_id *pci_id)
526{
527 u16 cmd;
528 unsigned char pci_latency;
529
530 CX18_DEBUG_INFO("Enabling pci device\n");
531
532 if (pci_enable_device(dev)) {
533 CX18_ERR("Can't enable device %d!\n", cx->num);
534 return -EIO;
535 }
536 if (pci_set_dma_mask(dev, 0xffffffff)) {
537 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
538 return -EIO;
539 }
540 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
541 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
542 return -EIO;
543 }
544
4519064c 545 /* Enable bus mastering and memory mapped IO for the CX23418 */
1c1e45d1 546 pci_read_config_word(dev, PCI_COMMAND, &cmd);
4519064c 547 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
1c1e45d1
HV		 548 pci_write_config_word(dev, PCI_COMMAND, cmd);
549
550 pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
551 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
552
553 if (pci_latency < 64 && cx18_pci_latency) {
554 CX18_INFO("Unreasonably low latency timer, "
555 "setting to 64 (was %d)\n", pci_latency);
556 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
557 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
558 }
1c1e45d1
HV		 559
560 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
561 "irq: %d, latency: %d, memory: 0x%lx\n",
562 cx->dev->device, cx->card_rev, dev->bus->number,
563 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
564 cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
565
566 return 0;
567}
568
6a4a7935 569#ifdef MODULE
1c1e45d1
HV		 570static u32 cx18_request_module(struct cx18 *cx, u32 hw,
571 const char *name, u32 id)
572{
573 if ((hw & id) == 0)
574 return hw;
575 if (request_module(name) != 0) {
576 CX18_ERR("Failed to load module %s\n", name);
577 return hw & ~id;
578 }
579 CX18_DEBUG_INFO("Loaded module %s\n", name);
580 return hw;
581}
6a4a7935 582#endif
1c1e45d1
HV		 583
584static void cx18_load_and_init_modules(struct cx18 *cx)
585{
586 u32 hw = cx->card->hw_all;
587 int i;
588
6a4a7935 589#ifdef MODULE
1c1e45d1 590 /* load modules */
58ae1c23 591#ifdef CONFIG_MEDIA_TUNER_MODULE
1c1e45d1
HV		 592 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
593#endif
58ae1c23 594#ifdef CONFIG_VIDEO_CS5345_MODULE
1c1e45d1 595 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
6a4a7935 596#endif
1c1e45d1
HV		 597#endif
598
599 /* check which i2c devices are actually found */
600 for (i = 0; i < 32; i++) {
601 u32 device = 1 << i;
602
603 if (!(device & hw))
604 continue;
605 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
606 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
607 /* These 'devices' do not use i2c probing */
608 cx->hw_flags |= device;
609 continue;
610 }
611 cx18_i2c_register(cx, i);
612 if (cx18_i2c_hw_addr(cx, device) > 0)
613 cx->hw_flags |= device;
614 }
615
616 hw = cx->hw_flags;
617}
618
619static int __devinit cx18_probe(struct pci_dev *dev,
620 const struct pci_device_id *pci_id)
621{
622 int retval = 0;
ff086575 623 int i;
1c1e45d1
HV		 624 int vbi_buf_size;
625 u32 devtype;
626 struct cx18 *cx;
627
628 spin_lock(&cx18_cards_lock);
629
630 /* Make sure we've got a place for this card */
631 if (cx18_cards_active == CX18_MAX_CARDS) {
632 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
633 cx18_cards_active);
634 spin_unlock(&cx18_cards_lock);
635 return -ENOMEM;
636 }
637
638 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
cb6969e8 639 if (!cx) {
1c1e45d1
HV		 640 spin_unlock(&cx18_cards_lock);
641 return -ENOMEM;
642 }
643 cx18_cards[cx18_cards_active] = cx;
644 cx->dev = dev;
645 cx->num = cx18_cards_active++;
b4ac3c8d 646 snprintf(cx->name, sizeof(cx->name), "cx18-%d", cx->num);
1c1e45d1
HV		 647 CX18_INFO("Initializing card #%d\n", cx->num);
648
649 spin_unlock(&cx18_cards_lock);
650
651 cx18_process_options(cx);
652 if (cx->options.cardtype == -1) {
653 retval = -ENODEV;
654 goto err;
655 }
656 if (cx18_init_struct1(cx)) {
657 retval = -ENOMEM;
658 goto err;
659 }
660
661 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
662
663 /* PCI Device Setup */
664 retval = cx18_setup_pci(cx, dev, pci_id);
665 if (retval != 0) {
666 if (retval == -EIO)
667 goto free_workqueue;
668 else if (retval == -ENXIO)
669 goto free_mem;
670 }
671 /* save cx in the pci struct for later use */
672 pci_set_drvdata(dev, cx);
673
674 /* map io memory */
675 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
676 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
677 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
678 CX18_MEM_SIZE);
679 if (!cx->enc_mem) {
680 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
681 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
682 retval = -ENOMEM;
683 goto free_mem;
684 }
685 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
b1526421 686 devtype = cx18_read_reg(cx, 0xC72028);
1c1e45d1
HV		 687 switch (devtype & 0xff000000) {
688 case 0xff000000:
689 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
690 break;
691 case 0x01000000:
692 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
693 break;
694 default:
695 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
696 break;
697 }
698
699 cx18_init_power(cx, 1);
700 cx18_init_memory(cx);
701
990c81c8 702 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
1c1e45d1
HV		 703 cx18_init_scb(cx);
704
705 cx18_gpio_init(cx);
706
707 /* active i2c */
708 CX18_DEBUG_INFO("activating i2c...\n");
9b4a7c8a
AW		 709 retval = init_cx18_i2c(cx);
710 if (retval) {
1c1e45d1
HV		 711 CX18_ERR("Could not initialize i2c\n");
712 goto free_map;
713 }
714
715 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
716
717 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
718 /* Based on the model number the cardtype may be changed.
719 The PCI IDs are not always reliable. */
720 cx18_process_eeprom(cx);
721 }
722 if (cx->card->comment)
723 CX18_INFO("%s", cx->card->comment);
724 if (cx->card->v4l2_capabilities == 0) {
725 retval = -ENODEV;
726 goto free_i2c;
727 }
728 cx18_init_memory(cx);
729
730 /* Register IRQ */
731 retval = request_irq(cx->dev->irq, cx18_irq_handler,
732 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
733 if (retval) {
734 CX18_ERR("Failed to register irq %d\n", retval);
735 goto free_i2c;
736 }
737
738 if (cx->std == 0)
739 cx->std = V4L2_STD_NTSC_M;
740
741 if (cx->options.tuner == -1) {
742 int i;
743
744 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
745 if ((cx->std & cx->card->tuners[i].std) == 0)
746 continue;
747 cx->options.tuner = cx->card->tuners[i].tuner;
748 break;
749 }
750 }
751 /* if no tuner was found, then pick the first tuner in the card list */
752 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
753 cx->std = cx->card->tuners[0].std;
c3cb4d95
HV		 754 if (cx->std & V4L2_STD_PAL)
755 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
756 else if (cx->std & V4L2_STD_NTSC)
757 cx->std = V4L2_STD_NTSC_M;
758 else if (cx->std & V4L2_STD_SECAM)
759 cx->std = V4L2_STD_SECAM_L;
1c1e45d1
HV		 760 cx->options.tuner = cx->card->tuners[0].tuner;
761 }
762 if (cx->options.radio == -1)
763 cx->options.radio = (cx->card->radio_input.audio_type != 0);
764
765 /* The card is now fully identified, continue with card-specific
766 initialization. */
767 cx18_init_struct2(cx);
768
769 cx18_load_and_init_modules(cx);
770
771 if (cx->std & V4L2_STD_525_60) {
772 cx->is_60hz = 1;
773 cx->is_out_60hz = 1;
774 } else {
775 cx->is_50hz = 1;
776 cx->is_out_50hz = 1;
777 }
778 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
779
780 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
781 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
782 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
783 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
784 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
785 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
786
787 if (cx->options.radio > 0)
788 cx->v4l2_cap |= V4L2_CAP_RADIO;
789
1c1e45d1
HV		 790 if (cx->options.tuner > -1) {
791 struct tuner_setup setup;
792
793 setup.addr = ADDR_UNSET;
794 setup.type = cx->options.tuner;
795 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
796 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
797 cx18_reset_tuner_gpio : NULL;
798 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
799 if (setup.type == TUNER_XC2028) {
800 static struct xc2028_ctrl ctrl = {
801 .fname = XC2028_DEFAULT_FIRMWARE,
802 .max_len = 64,
803 };
804 struct v4l2_priv_tun_config cfg = {
805 .tuner = cx->options.tuner,
806 .priv = &ctrl,
807 };
808 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
809 }
810 }
811
812 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
813 are not. */
814 cx->tuner_std = cx->std;
815
5e7fdc5e
HV		 816 retval = cx18_streams_setup(cx);
817 if (retval) {
818 CX18_ERR("Error %d setting up streams\n", retval);
819 goto free_irq;
820 }
821 retval = cx18_streams_register(cx);
822 if (retval) {
823 CX18_ERR("Error %d registering devices\n", retval);
824 goto free_streams;
825 }
1c1e45d1
HV		 826
827 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
828
829 return 0;
830
831free_streams:
3f98387e 832 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 833free_irq:
834 free_irq(cx->dev->irq, (void *)cx);
835free_i2c:
836 exit_cx18_i2c(cx);
837free_map:
838 cx18_iounmap(cx);
839free_mem:
840 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
841free_workqueue:
1d6782bd 842 destroy_workqueue(cx->work_queue);
1c1e45d1
HV		 843err:
844 if (retval == 0)
845 retval = -ENODEV;
846 CX18_ERR("Error %d on initialization\n", retval);
d267d851 847 cx18_log_statistics(cx);
1c1e45d1 848
ff086575
AW		 849 i = cx->num;
850 spin_lock(&cx18_cards_lock);
851 kfree(cx18_cards[i]);
852 cx18_cards[i] = NULL;
853 spin_unlock(&cx18_cards_lock);
1c1e45d1
HV		 854 return retval;
855}
856
857int cx18_init_on_first_open(struct cx18 *cx)
858{
859 int video_input;
860 int fw_retry_count = 3;
861 struct v4l2_frequency vf;
3b6fe58f
AW		 862 struct cx18_open_id fh;
863
864 fh.cx = cx;
1c1e45d1
HV		 865
866 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
867 return -ENXIO;
868
869 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
870 return 0;
871
872 while (--fw_retry_count > 0) {
873 /* load firmware */
874 if (cx18_firmware_init(cx) == 0)
875 break;
876 if (fw_retry_count > 1)
877 CX18_WARN("Retry loading firmware\n");
878 }
879
880 if (fw_retry_count == 0) {
881 set_bit(CX18_F_I_FAILED, &cx->i_flags);
882 return -ENXIO;
883 }
884 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
885
886 /* Init the firmware twice to work around a silicon bug
887 * transport related. */
888
889 fw_retry_count = 3;
890 while (--fw_retry_count > 0) {
891 /* load firmware */
892 if (cx18_firmware_init(cx) == 0)
893 break;
894 if (fw_retry_count > 1)
895 CX18_WARN("Retry loading firmware\n");
896 }
897
898 if (fw_retry_count == 0) {
899 set_bit(CX18_F_I_FAILED, &cx->i_flags);
900 return -ENXIO;
901 }
902
903 vf.tuner = 0;
904 vf.type = V4L2_TUNER_ANALOG_TV;
905 vf.frequency = 6400; /* the tuner 'baseline' frequency */
906
907 /* Set initial frequency. For PAL/SECAM broadcasts no
908 'default' channel exists AFAIK. */
909 if (cx->std == V4L2_STD_NTSC_M_JP)
910 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
911 else if (cx->std & V4L2_STD_NTSC_M)
912 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
913
914 video_input = cx->active_input;
915 cx->active_input++; /* Force update of input */
3b6fe58f 916 cx18_s_input(NULL, &fh, video_input);
1c1e45d1
HV		 917
918 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
919 in one place. */
920 cx->std++; /* Force full standard initialization */
3b6fe58f
AW		 921 cx18_s_std(NULL, &fh, &cx->tuner_std);
922 cx18_s_frequency(NULL, &fh, &vf);
1c1e45d1
HV		 923 return 0;
924}
925
926static void cx18_remove(struct pci_dev *pci_dev)
927{
928 struct cx18 *cx = pci_get_drvdata(pci_dev);
929
930 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
931
932 /* Stop all captures */
933 CX18_DEBUG_INFO("Stopping all streams\n");
31554ae5 934 if (atomic_read(&cx->tot_capturing) > 0)
1c1e45d1
HV		 935 cx18_stop_all_captures(cx);
936
937 /* Interrupts */
b1526421
AW		 938 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
939 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1c1e45d1
HV		 940
941 cx18_halt_firmware(cx);
942
1d6782bd
AW		 943 flush_workqueue(cx->work_queue);
944 destroy_workqueue(cx->work_queue);
945
3f98387e 946 cx18_streams_cleanup(cx, 1);
1c1e45d1
HV		 947
948 exit_cx18_i2c(cx);
949
950 free_irq(cx->dev->irq, (void *)cx);
951
cba627a5 952 cx18_iounmap(cx);
1c1e45d1
HV		 953
954 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
955
956 pci_disable_device(cx->dev);
957
d267d851 958 cx18_log_statistics(cx);
1c1e45d1
HV		 959 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
960}
961
962/* define a pci_driver for card detection */
963static struct pci_driver cx18_pci_driver = {
964 .name = "cx18",
965 .id_table = cx18_pci_tbl,
966 .probe = cx18_probe,
967 .remove = cx18_remove,
968};
969
970static int module_start(void)
971{
972 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
973
974 memset(cx18_cards, 0, sizeof(cx18_cards));
975
976 /* Validate parameters */
977 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
dd89601d 978 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1c1e45d1
HV		 979 CX18_MAX_CARDS - 1);
980 return -1;
981 }
982
983 if (cx18_debug < 0 || cx18_debug > 511) {
984 cx18_debug = 0;
985 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
986 }
987
988 if (pci_register_driver(&cx18_pci_driver)) {
989 printk(KERN_ERR "cx18: Error detecting PCI card\n");
990 return -ENODEV;
991 }
992 printk(KERN_INFO "cx18: End initialization\n");
993 return 0;
994}
995
996static void module_cleanup(void)
997{
998 int i;
999
1000 pci_unregister_driver(&cx18_pci_driver);
1001
1002 for (i = 0; i < cx18_cards_active; i++) {
1003 if (cx18_cards[i] == NULL)
1004 continue;
1005 kfree(cx18_cards[i]);
1006 }
1007}
1008
1009module_init(module_start);
1010module_exit(module_cleanup);
kernel source for telekom puls (alcatel/mediatek)