2 * cx18 driver initialization and card probing
4 * Derived from ivtv-driver.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
7 * Copyright (C) 2008 Andy Walls <awalls@radix.net>
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.
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.
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
25 #include "cx18-driver.h"
27 #include "cx18-version.h"
28 #include "cx18-cards.h"
31 #include "cx18-gpio.h"
32 #include "cx18-firmware.h"
33 #include "cx18-streams.h"
34 #include "cx18-av-core.h"
36 #include "cx18-mailbox.h"
37 #include "cx18-ioctl.h"
38 #include "tuner-xc2028.h"
40 #include <media/tveeprom.h>
42 /* If you have already X v4l cards, then set this to X. This way
43 the device numbers stay matched. Example: you have a WinTV card
44 without radio and a Compro H900 with. Normally this would give a
45 video1 device together with a radio0 device for the Compro. By
46 setting this to 1 you ensure that radio0 is now also radio1. */
49 /* add your revision and whatnot here */
50 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
51 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
52 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
56 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
58 static atomic_t cx18_instance = ATOMIC_INIT(0);
60 /* Parameter declarations */
61 static int cardtype[CX18_MAX_CARDS];
62 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
63 -1, -1, -1, -1, -1, -1, -1, -1,
64 -1, -1, -1, -1, -1, -1, -1, -1,
65 -1, -1, -1, -1, -1, -1, -1, -1 };
66 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
67 -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 static unsigned cardtype_c = 1;
71 static unsigned tuner_c = 1;
72 static unsigned radio_c = 1;
73 static char pal[] = "--";
74 static char secam[] = "--";
75 static char ntsc[] = "-";
78 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
79 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
80 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
81 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
82 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
83 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
85 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
86 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
87 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
88 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
89 /* VBI bufsize based on standards supported by card tuner for now */
90 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
92 static int enc_ts_bufs = -1;
93 static int enc_mpg_bufs = -1;
94 static int enc_idx_bufs = -1;
95 static int enc_yuv_bufs = -1;
96 static int enc_vbi_bufs = -1;
97 static int enc_pcm_bufs = -1;
100 static int cx18_pci_latency = 1;
102 static int mmio_ndelay;
103 static int retry_mmio = 1;
107 module_param_array(tuner, int, &tuner_c, 0644);
108 module_param_array(radio, bool, &radio_c, 0644);
109 module_param_array(cardtype, int, &cardtype_c, 0644);
110 module_param_string(pal, pal, sizeof(pal), 0644);
111 module_param_string(secam, secam, sizeof(secam), 0644);
112 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
113 module_param_named(debug, cx18_debug, int, 0644);
114 module_param(mmio_ndelay, int, 0644);
115 module_param(retry_mmio, int, 0644);
116 module_param(cx18_pci_latency, int, 0644);
117 module_param(cx18_first_minor, int, 0644);
119 module_param(enc_ts_buffers, int, 0644);
120 module_param(enc_mpg_buffers, int, 0644);
121 module_param(enc_idx_buffers, int, 0644);
122 module_param(enc_yuv_buffers, int, 0644);
123 module_param(enc_vbi_buffers, int, 0644);
124 module_param(enc_pcm_buffers, int, 0644);
126 module_param(enc_ts_bufsize, int, 0644);
127 module_param(enc_mpg_bufsize, int, 0644);
128 module_param(enc_idx_bufsize, int, 0644);
129 module_param(enc_yuv_bufsize, int, 0644);
130 /* VBI bufsize based on standards supported by card tuner for now */
131 module_param(enc_pcm_bufsize, int, 0644);
133 module_param(enc_ts_bufs, int, 0644);
134 module_param(enc_mpg_bufs, int, 0644);
135 module_param(enc_idx_bufs, int, 0644);
136 module_param(enc_yuv_bufs, int, 0644);
137 module_param(enc_vbi_bufs, int, 0644);
138 module_param(enc_pcm_bufs, int, 0644);
140 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
141 "\t\t\tsee tuner.h for values");
142 MODULE_PARM_DESC(radio,
143 "Enable or disable the radio. Use only if autodetection\n"
144 "\t\t\tfails. 0 = disable, 1 = enable");
145 MODULE_PARM_DESC(cardtype,
146 "Only use this option if your card is not detected properly.\n"
147 "\t\tSpecify card type:\n"
148 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
149 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
150 "\t\t\t 3 = Compro VideoMate H900\n"
151 "\t\t\t 4 = Yuan MPC718\n"
152 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
153 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
154 "\t\t\t 7 = Leadtek WinFast PVR2100/DVR3100 H\n"
155 "\t\t\t 0 = Autodetect (default)\n"
156 "\t\t\t-1 = Ignore this card\n\t\t");
157 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
158 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
159 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
160 MODULE_PARM_DESC(debug,
161 "Debug level (bitmask). Default: 0\n"
162 "\t\t\t 1/0x0001: warning\n"
163 "\t\t\t 2/0x0002: info\n"
164 "\t\t\t 4/0x0004: mailbox\n"
165 "\t\t\t 8/0x0008: dma\n"
166 "\t\t\t 16/0x0010: ioctl\n"
167 "\t\t\t 32/0x0020: file\n"
168 "\t\t\t 64/0x0040: i2c\n"
169 "\t\t\t128/0x0080: irq\n"
170 "\t\t\t256/0x0100: high volume\n");
171 MODULE_PARM_DESC(cx18_pci_latency,
172 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
173 "\t\t\tDefault: Yes");
174 MODULE_PARM_DESC(retry_mmio,
175 "(Deprecated) MMIO writes are now always checked and retried\n"
176 "\t\t\tEffectively: 1 [Yes]");
177 MODULE_PARM_DESC(mmio_ndelay,
178 "(Deprecated) MMIO accesses are now never purposely delayed\n"
179 "\t\t\tEffectively: 0 ns");
180 MODULE_PARM_DESC(enc_ts_buffers,
181 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
182 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
183 MODULE_PARM_DESC(enc_ts_bufsize,
184 "Size of an encoder TS buffer (kB)\n"
185 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
186 MODULE_PARM_DESC(enc_ts_bufs,
187 "Number of encoder TS buffers\n"
188 "\t\t\tDefault is computed from other enc_ts_* parameters");
189 MODULE_PARM_DESC(enc_mpg_buffers,
190 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
191 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
192 MODULE_PARM_DESC(enc_mpg_bufsize,
193 "Size of an encoder MPG buffer (kB)\n"
194 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
195 MODULE_PARM_DESC(enc_mpg_bufs,
196 "Number of encoder MPG buffers\n"
197 "\t\t\tDefault is computed from other enc_mpg_* parameters");
198 MODULE_PARM_DESC(enc_idx_buffers,
199 "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
200 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS));
201 MODULE_PARM_DESC(enc_idx_bufsize,
202 "Size of an encoder IDX buffer (kB)\n"
203 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
204 MODULE_PARM_DESC(enc_idx_bufs,
205 "Number of encoder IDX buffers\n"
206 "\t\t\tDefault is computed from other enc_idx_* parameters");
207 MODULE_PARM_DESC(enc_yuv_buffers,
208 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
209 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
210 MODULE_PARM_DESC(enc_yuv_bufsize,
211 "Size of an encoder YUV buffer (kB)\n"
212 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFSIZE));
213 MODULE_PARM_DESC(enc_yuv_bufs,
214 "Number of encoder YUV buffers\n"
215 "\t\t\tDefault is computed from other enc_yuv_* parameters");
216 MODULE_PARM_DESC(enc_vbi_buffers,
217 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
218 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
219 MODULE_PARM_DESC(enc_vbi_bufs,
220 "Number of encoder VBI buffers\n"
221 "\t\t\tDefault is computed from enc_vbi_buffers & tuner std");
222 MODULE_PARM_DESC(enc_pcm_buffers,
223 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
224 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
225 MODULE_PARM_DESC(enc_pcm_bufsize,
226 "Size of an encoder PCM buffer (kB)\n"
227 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
228 MODULE_PARM_DESC(enc_pcm_bufs,
229 "Number of encoder PCM buffers\n"
230 "\t\t\tDefault is computed from other enc_pcm_* parameters");
232 MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
234 MODULE_AUTHOR("Hans Verkuil");
235 MODULE_DESCRIPTION("CX23418 driver");
236 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
237 MODULE_LICENSE("GPL");
239 MODULE_VERSION(CX18_VERSION);
241 /* Generic utility functions */
242 int cx18_msleep_timeout(unsigned int msecs, int intr)
244 long int timeout = msecs_to_jiffies(msecs);
248 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
249 timeout = schedule_timeout(timeout);
250 sig = intr ? signal_pending(current) : 0;
251 } while (!sig && timeout);
255 /* Release ioremapped memory */
256 static void cx18_iounmap(struct cx18 *cx)
261 /* Release io memory */
262 if (cx->enc_mem != NULL) {
263 CX18_DEBUG_INFO("releasing enc_mem\n");
264 iounmap(cx->enc_mem);
269 /* Hauppauge card? get values from tveeprom */
270 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
275 memset(&c, 0, sizeof(c));
276 strncpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
277 c.name[sizeof(c.name)-1] = '\0';
278 c.adapter = &cx->i2c_adap[0];
281 tveeprom_read(&c, eedata, sizeof(eedata));
282 tveeprom_hauppauge_analog(&c, tv, eedata);
285 static void cx18_process_eeprom(struct cx18 *cx)
289 cx18_read_eeprom(cx, &tv);
291 /* Many thanks to Steven Toth from Hauppauge for providing the
293 /* Note: the Samsung memory models cannot be reliably determined
294 from the model number. Use the cardtype module option if you
295 have one of these preproduction models. */
297 case 74000 ... 74999:
298 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
301 CX18_ERR("Invalid EEPROM\n");
304 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
305 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
309 cx->v4l2_cap = cx->card->v4l2_capabilities;
310 cx->card_name = cx->card->name;
311 cx->card_i2c = cx->card->i2c;
313 CX18_INFO("Autodetected %s\n", cx->card_name);
315 if (tv.tuner_type == TUNER_ABSENT)
316 CX18_ERR("tveeprom cannot autodetect tuner!");
318 if (cx->options.tuner == -1)
319 cx->options.tuner = tv.tuner_type;
320 if (cx->options.radio == -1)
321 cx->options.radio = (tv.has_radio != 0);
324 /* user specified tuner standard */
327 /* autodetect tuner standard */
328 if (tv.tuner_formats & V4L2_STD_PAL) {
329 CX18_DEBUG_INFO("PAL tuner detected\n");
330 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
331 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
332 CX18_DEBUG_INFO("NTSC tuner detected\n");
333 cx->std |= V4L2_STD_NTSC_M;
334 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
335 CX18_DEBUG_INFO("SECAM tuner detected\n");
336 cx->std |= V4L2_STD_SECAM_L;
338 CX18_INFO("No tuner detected, default to NTSC-M\n");
339 cx->std |= V4L2_STD_NTSC_M;
343 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
347 return V4L2_STD_PAL_60;
352 return V4L2_STD_PAL_BG;
355 return V4L2_STD_PAL_H;
358 if (pal[1] == 'c' || pal[1] == 'C')
359 return V4L2_STD_PAL_Nc;
360 return V4L2_STD_PAL_N;
363 return V4L2_STD_PAL_I;
368 return V4L2_STD_PAL_DK;
371 return V4L2_STD_PAL_M;
375 CX18_WARN("pal= argument not recognised\n");
386 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
391 return V4L2_STD_SECAM_DK;
394 if (secam[1] == 'C' || secam[1] == 'c')
395 return V4L2_STD_SECAM_LC;
396 return V4L2_STD_SECAM_L;
400 CX18_WARN("secam= argument not recognised\n");
407 return V4L2_STD_NTSC_M;
410 return V4L2_STD_NTSC_M_JP;
413 return V4L2_STD_NTSC_M_KR;
417 CX18_WARN("ntsc= argument not recognised\n");
425 static void cx18_process_options(struct cx18 *cx)
429 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
430 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
431 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
432 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
433 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
434 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
435 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
437 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
438 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
439 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
440 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
441 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
442 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
443 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
445 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
446 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
447 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
448 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
449 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
450 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
451 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
453 /* Ensure stream_buffers & stream_buf_size are valid */
454 for (i = 0; i < CX18_MAX_STREAMS; i++) {
455 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
456 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
457 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
458 cx->options.megabytes[i] = 0;
459 cx->stream_buffers[i] = 0;
460 cx->stream_buf_size[i] = 0;
464 * VBI is a special case where the stream_buf_size is fixed
465 * and already in bytes
467 if (i == CX18_ENC_STREAM_TYPE_VBI) {
468 if (cx->stream_buffers[i] < 0) {
469 cx->stream_buffers[i] =
470 cx->options.megabytes[i] * 1024 * 1024
471 / cx->stream_buf_size[i];
473 /* N.B. This might round down to 0 */
474 cx->options.megabytes[i] =
475 cx->stream_buffers[i]
476 * cx->stream_buf_size[i]/(1024 * 1024);
480 /* All other streams have stream_buf_size in kB at this point */
481 if (cx->stream_buffers[i] < 0) {
482 cx->stream_buffers[i] = cx->options.megabytes[i] * 1024
483 / cx->stream_buf_size[i];
485 /* N.B. This might round down to 0 */
486 cx->options.megabytes[i] =
487 cx->stream_buffers[i] * cx->stream_buf_size[i] / 1024;
489 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
492 cx->options.cardtype = cardtype[cx->instance];
493 cx->options.tuner = tuner[cx->instance];
494 cx->options.radio = radio[cx->instance];
496 cx->std = cx18_parse_std(cx);
497 if (cx->options.cardtype == -1) {
498 CX18_INFO("Ignore card\n");
501 cx->card = cx18_get_card(cx->options.cardtype - 1);
503 CX18_INFO("User specified %s card\n", cx->card->name);
504 else if (cx->options.cardtype != 0)
505 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
506 if (cx->card == NULL) {
507 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
508 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
509 CX18_INFO("Autodetected Hauppauge card\n");
512 if (cx->card == NULL) {
513 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
514 if (cx->card->pci_list == NULL)
516 for (j = 0; cx->card->pci_list[j].device; j++) {
517 if (cx->pci_dev->device !=
518 cx->card->pci_list[j].device)
520 if (cx->pci_dev->subsystem_vendor !=
521 cx->card->pci_list[j].subsystem_vendor)
523 if (cx->pci_dev->subsystem_device !=
524 cx->card->pci_list[j].subsystem_device)
526 CX18_INFO("Autodetected %s card\n", cx->card->name);
533 if (cx->card == NULL) {
534 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
535 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
536 cx->pci_dev->vendor, cx->pci_dev->device);
537 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
538 cx->pci_dev->subsystem_vendor,
539 cx->pci_dev->subsystem_device);
540 CX18_ERR("Defaulting to %s card\n", cx->card->name);
541 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
542 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
543 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
545 cx->v4l2_cap = cx->card->v4l2_capabilities;
546 cx->card_name = cx->card->name;
547 cx->card_i2c = cx->card->i2c;
550 /* Precondition: the cx18 structure has been memset to 0. Only
551 the dev and instance fields have been filled in.
552 No assumptions on the card type may be made here (see cx18_init_struct2
555 static int __devinit cx18_init_struct1(struct cx18 *cx)
559 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
561 mutex_init(&cx->serialize_lock);
562 mutex_init(&cx->gpio_lock);
563 mutex_init(&cx->epu2apu_mb_lock);
564 mutex_init(&cx->epu2cpu_mb_lock);
566 cx->work_queue = create_singlethread_workqueue(cx->v4l2_dev.name);
567 if (cx->work_queue == NULL) {
568 CX18_ERR("Unable to create work hander thread\n");
572 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++) {
573 cx->epu_work_order[i].cx = cx;
574 cx->epu_work_order[i].str = cx->epu_debug_str;
575 INIT_WORK(&cx->epu_work_order[i].work, cx18_epu_work_handler);
578 /* start counting open_id at 1 */
581 /* Initial settings */
582 cx2341x_fill_defaults(&cx->params);
583 cx->temporal_strength = cx->params.video_temporal_filter;
584 cx->spatial_strength = cx->params.video_spatial_filter;
585 cx->filter_mode = cx->params.video_spatial_filter_mode |
586 (cx->params.video_temporal_filter_mode << 1) |
587 (cx->params.video_median_filter_type << 2);
588 cx->params.port = CX2341X_PORT_MEMORY;
589 cx->params.capabilities =
590 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_AC3 | CX2341X_CAP_HAS_SLICED_VBI;
591 init_waitqueue_head(&cx->cap_w);
592 init_waitqueue_head(&cx->mb_apu_waitq);
593 init_waitqueue_head(&cx->mb_cpu_waitq);
594 init_waitqueue_head(&cx->dma_waitq);
597 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
598 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
603 /* Second initialization part. Here the card type has been
605 static void __devinit cx18_init_struct2(struct cx18 *cx)
609 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
610 if (cx->card->video_inputs[i].video_type == 0)
613 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
614 if (cx->card->audio_inputs[i].audio_type == 0)
616 cx->nof_audio_inputs = i;
618 /* Find tuner input */
619 for (i = 0; i < cx->nof_inputs; i++) {
620 if (cx->card->video_inputs[i].video_type ==
621 CX18_CARD_INPUT_VID_TUNER)
624 if (i == cx->nof_inputs)
626 cx->active_input = i;
627 cx->audio_input = cx->card->video_inputs[i].audio_index;
630 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
631 const struct pci_device_id *pci_id)
634 unsigned char pci_latency;
636 CX18_DEBUG_INFO("Enabling pci device\n");
638 if (pci_enable_device(pci_dev)) {
639 CX18_ERR("Can't enable device %d!\n", cx->instance);
642 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
643 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
646 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
647 CX18_ERR("Cannot request encoder memory region, card %d\n",
652 /* Enable bus mastering and memory mapped IO for the CX23418 */
653 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
654 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
655 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
657 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
658 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
660 if (pci_latency < 64 && cx18_pci_latency) {
661 CX18_INFO("Unreasonably low latency timer, "
662 "setting to 64 (was %d)\n", pci_latency);
663 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
664 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
667 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
668 "irq: %d, latency: %d, memory: 0x%lx\n",
669 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
670 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
671 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
676 static void cx18_init_subdevs(struct cx18 *cx)
678 u32 hw = cx->card->hw_all;
682 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
689 case CX18_HW_TVEEPROM:
690 /* These subordinate devices do not use probing */
691 cx->hw_flags |= device;
694 /* The A/V decoder gets probed earlier to set PLLs */
695 /* Just note that the card uses it (i.e. has analog) */
696 cx->hw_flags |= device;
698 case CX18_HW_GPIO_RESET_CTRL:
700 * The Reset Controller gets probed and added to
701 * hw_flags earlier for i2c adapter/bus initialization
704 case CX18_HW_GPIO_MUX:
705 if (cx18_gpio_register(cx, device) == 0)
706 cx->hw_flags |= device;
709 if (cx18_i2c_register(cx, i) == 0)
710 cx->hw_flags |= device;
715 if (cx->hw_flags & CX18_HW_418_AV)
716 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
718 if (cx->card->hw_muxer != 0)
719 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
722 static int __devinit cx18_probe(struct pci_dev *pci_dev,
723 const struct pci_device_id *pci_id)
730 /* FIXME - module parameter arrays constrain max instances */
731 i = atomic_inc_return(&cx18_instance) - 1;
732 if (i >= CX18_MAX_CARDS) {
733 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
734 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
738 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
740 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
744 cx->pci_dev = pci_dev;
747 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
749 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
754 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
756 CX18_INFO("Initializing card %d\n", cx->instance);
758 cx18_process_options(cx);
759 if (cx->options.cardtype == -1) {
763 if (cx18_init_struct1(cx)) {
768 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
770 /* PCI Device Setup */
771 retval = cx18_setup_pci(cx, pci_dev, pci_id);
776 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
777 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
778 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
781 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
782 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
786 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
787 devtype = cx18_read_reg(cx, 0xC72028);
788 switch (devtype & 0xff000000) {
790 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
793 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
796 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
800 cx18_init_power(cx, 1);
801 cx18_init_memory(cx);
803 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
808 /* Initialize integrated A/V decoder early to set PLLs, just in case */
809 retval = cx18_av_probe(cx);
811 CX18_ERR("Could not register A/V decoder subdevice\n");
814 cx18_call_hw(cx, CX18_HW_418_AV, core, init, (u32) CX18_AV_INIT_PLLS);
816 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
817 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
818 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
819 CX18_WARN("Could not register GPIO reset controller"
820 "subdevice; proceeding anyway.\n");
822 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
826 CX18_DEBUG_INFO("activating i2c...\n");
827 retval = init_cx18_i2c(cx);
829 CX18_ERR("Could not initialize i2c\n");
833 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
834 /* Based on the model number the cardtype may be changed.
835 The PCI IDs are not always reliable. */
836 cx18_process_eeprom(cx);
838 if (cx->card->comment)
839 CX18_INFO("%s", cx->card->comment);
840 if (cx->card->v4l2_capabilities == 0) {
844 cx18_init_memory(cx);
848 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
849 IRQF_SHARED | IRQF_DISABLED,
850 cx->v4l2_dev.name, (void *)cx);
852 CX18_ERR("Failed to register irq %d\n", retval);
857 cx->std = V4L2_STD_NTSC_M;
859 if (cx->options.tuner == -1) {
860 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
861 if ((cx->std & cx->card->tuners[i].std) == 0)
863 cx->options.tuner = cx->card->tuners[i].tuner;
867 /* if no tuner was found, then pick the first tuner in the card list */
868 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
869 cx->std = cx->card->tuners[0].std;
870 if (cx->std & V4L2_STD_PAL)
871 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
872 else if (cx->std & V4L2_STD_NTSC)
873 cx->std = V4L2_STD_NTSC_M;
874 else if (cx->std & V4L2_STD_SECAM)
875 cx->std = V4L2_STD_SECAM_L;
876 cx->options.tuner = cx->card->tuners[0].tuner;
878 if (cx->options.radio == -1)
879 cx->options.radio = (cx->card->radio_input.audio_type != 0);
881 /* The card is now fully identified, continue with card-specific
883 cx18_init_struct2(cx);
885 cx18_init_subdevs(cx);
887 if (cx->std & V4L2_STD_525_60) {
894 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
896 if (cx->options.radio > 0)
897 cx->v4l2_cap |= V4L2_CAP_RADIO;
899 if (cx->options.tuner > -1) {
900 struct tuner_setup setup;
902 setup.addr = ADDR_UNSET;
903 setup.type = cx->options.tuner;
904 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
905 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
906 cx18_reset_tuner_gpio : NULL;
907 cx18_call_all(cx, tuner, s_type_addr, &setup);
908 if (setup.type == TUNER_XC2028) {
909 static struct xc2028_ctrl ctrl = {
910 .fname = XC2028_DEFAULT_FIRMWARE,
913 struct v4l2_priv_tun_config cfg = {
914 .tuner = cx->options.tuner,
917 cx18_call_all(cx, tuner, s_config, &cfg);
921 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
923 cx->tuner_std = cx->std;
925 retval = cx18_streams_setup(cx);
927 CX18_ERR("Error %d setting up streams\n", retval);
930 retval = cx18_streams_register(cx);
932 CX18_ERR("Error %d registering devices\n", retval);
936 CX18_INFO("Initialized card: %s\n", cx->card_name);
940 cx18_streams_cleanup(cx, 1);
942 free_irq(cx->pci_dev->irq, (void *)cx);
948 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
950 destroy_workqueue(cx->work_queue);
954 CX18_ERR("Error %d on initialization\n", retval);
956 v4l2_device_unregister(&cx->v4l2_dev);
961 int cx18_init_on_first_open(struct cx18 *cx)
964 int fw_retry_count = 3;
965 struct v4l2_frequency vf;
966 struct cx18_open_id fh;
970 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
973 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
976 while (--fw_retry_count > 0) {
978 if (cx18_firmware_init(cx) == 0)
980 if (fw_retry_count > 1)
981 CX18_WARN("Retry loading firmware\n");
984 if (fw_retry_count == 0) {
985 set_bit(CX18_F_I_FAILED, &cx->i_flags);
988 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
991 * Init the firmware twice to work around a silicon bug
992 * with the digital TS.
994 * The second firmware load requires us to normalize the APU state,
995 * or the audio for the first analog capture will be badly incorrect.
997 * I can't seem to call APU_RESETAI and have it succeed without the
998 * APU capturing audio, so we start and stop it here to do the reset
1001 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1002 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1003 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1004 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1007 while (--fw_retry_count > 0) {
1009 if (cx18_firmware_init(cx) == 0)
1011 if (fw_retry_count > 1)
1012 CX18_WARN("Retry loading firmware\n");
1015 if (fw_retry_count == 0) {
1016 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1021 * The second firmware load requires us to normalize the APU state,
1022 * or the audio for the first analog capture will be badly incorrect.
1024 * I can't seem to call APU_RESETAI and have it succeed without the
1025 * APU capturing audio, so we start and stop it here to do the reset
1028 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1029 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1030 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1031 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1033 /* Init the A/V decoder, if it hasn't been already */
1034 v4l2_subdev_call(cx->sd_av, core, init, (u32) CX18_AV_INIT_NORMAL);
1037 vf.type = V4L2_TUNER_ANALOG_TV;
1038 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1040 /* Set initial frequency. For PAL/SECAM broadcasts no
1041 'default' channel exists AFAIK. */
1042 if (cx->std == V4L2_STD_NTSC_M_JP)
1043 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1044 else if (cx->std & V4L2_STD_NTSC_M)
1045 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1047 video_input = cx->active_input;
1048 cx->active_input++; /* Force update of input */
1049 cx18_s_input(NULL, &fh, video_input);
1051 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1053 cx->std++; /* Force full standard initialization */
1054 cx18_s_std(NULL, &fh, &cx->tuner_std);
1055 cx18_s_frequency(NULL, &fh, &vf);
1059 static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1062 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1063 cancel_work_sync(&cx->epu_work_order[i].work);
1066 static void cx18_remove(struct pci_dev *pci_dev)
1068 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1069 struct cx18 *cx = to_cx18(v4l2_dev);
1072 CX18_DEBUG_INFO("Removing Card\n");
1074 /* Stop all captures */
1075 CX18_DEBUG_INFO("Stopping all streams\n");
1076 if (atomic_read(&cx->tot_capturing) > 0)
1077 cx18_stop_all_captures(cx);
1080 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1081 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1083 cx18_halt_firmware(cx);
1085 cx18_cancel_epu_work_orders(cx);
1087 destroy_workqueue(cx->work_queue);
1089 cx18_streams_cleanup(cx, 1);
1093 free_irq(cx->pci_dev->irq, (void *)cx);
1097 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1099 pci_disable_device(cx->pci_dev);
1101 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1102 for (i = 0; i < CX18_VBI_FRAMES; i++)
1103 kfree(cx->vbi.sliced_mpeg_data[i]);
1105 CX18_INFO("Removed %s\n", cx->card_name);
1107 v4l2_device_unregister(v4l2_dev);
1111 /* define a pci_driver for card detection */
1112 static struct pci_driver cx18_pci_driver = {
1114 .id_table = cx18_pci_tbl,
1115 .probe = cx18_probe,
1116 .remove = cx18_remove,
1119 static int module_start(void)
1121 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1123 /* Validate parameters */
1124 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1125 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1126 CX18_MAX_CARDS - 1);
1130 if (cx18_debug < 0 || cx18_debug > 511) {
1132 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1135 if (pci_register_driver(&cx18_pci_driver)) {
1136 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1139 printk(KERN_INFO "cx18: End initialization\n");
1143 static void module_cleanup(void)
1145 pci_unregister_driver(&cx18_pci_driver);
1148 module_init(module_start);
1149 module_exit(module_cleanup);