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)
274 cx->i2c_client[0].addr = 0xA0 >> 1;
275 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
276 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
279 static void cx18_process_eeprom(struct cx18 *cx)
283 cx18_read_eeprom(cx, &tv);
285 /* Many thanks to Steven Toth from Hauppauge for providing the
287 /* Note: the Samsung memory models cannot be reliably determined
288 from the model number. Use the cardtype module option if you
289 have one of these preproduction models. */
291 case 74000 ... 74999:
292 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
295 CX18_ERR("Invalid EEPROM\n");
298 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
299 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
303 cx->v4l2_cap = cx->card->v4l2_capabilities;
304 cx->card_name = cx->card->name;
305 cx->card_i2c = cx->card->i2c;
307 CX18_INFO("Autodetected %s\n", cx->card_name);
309 if (tv.tuner_type == TUNER_ABSENT)
310 CX18_ERR("tveeprom cannot autodetect tuner!");
312 if (cx->options.tuner == -1)
313 cx->options.tuner = tv.tuner_type;
314 if (cx->options.radio == -1)
315 cx->options.radio = (tv.has_radio != 0);
318 /* user specified tuner standard */
321 /* autodetect tuner standard */
322 if (tv.tuner_formats & V4L2_STD_PAL) {
323 CX18_DEBUG_INFO("PAL tuner detected\n");
324 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
325 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
326 CX18_DEBUG_INFO("NTSC tuner detected\n");
327 cx->std |= V4L2_STD_NTSC_M;
328 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
329 CX18_DEBUG_INFO("SECAM tuner detected\n");
330 cx->std |= V4L2_STD_SECAM_L;
332 CX18_INFO("No tuner detected, default to NTSC-M\n");
333 cx->std |= V4L2_STD_NTSC_M;
337 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
341 return V4L2_STD_PAL_60;
346 return V4L2_STD_PAL_BG;
349 return V4L2_STD_PAL_H;
352 if (pal[1] == 'c' || pal[1] == 'C')
353 return V4L2_STD_PAL_Nc;
354 return V4L2_STD_PAL_N;
357 return V4L2_STD_PAL_I;
362 return V4L2_STD_PAL_DK;
365 return V4L2_STD_PAL_M;
369 CX18_WARN("pal= argument not recognised\n");
380 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
385 return V4L2_STD_SECAM_DK;
388 if (secam[1] == 'C' || secam[1] == 'c')
389 return V4L2_STD_SECAM_LC;
390 return V4L2_STD_SECAM_L;
394 CX18_WARN("secam= argument not recognised\n");
401 return V4L2_STD_NTSC_M;
404 return V4L2_STD_NTSC_M_JP;
407 return V4L2_STD_NTSC_M_KR;
411 CX18_WARN("ntsc= argument not recognised\n");
419 static void cx18_process_options(struct cx18 *cx)
423 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
424 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
425 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
426 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
427 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
428 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
429 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
431 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
432 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
433 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
434 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
435 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
436 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
437 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
439 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
440 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
441 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
442 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
443 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
444 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
445 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
447 /* Ensure stream_buffers & stream_buf_size are valid */
448 for (i = 0; i < CX18_MAX_STREAMS; i++) {
449 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
450 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
451 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
452 cx->options.megabytes[i] = 0;
453 cx->stream_buffers[i] = 0;
454 cx->stream_buf_size[i] = 0;
458 * VBI is a special case where the stream_buf_size is fixed
459 * and already in bytes
461 if (i == CX18_ENC_STREAM_TYPE_VBI) {
462 if (cx->stream_buffers[i] < 0) {
463 cx->stream_buffers[i] =
464 cx->options.megabytes[i] * 1024 * 1024
465 / cx->stream_buf_size[i];
467 /* N.B. This might round down to 0 */
468 cx->options.megabytes[i] =
469 cx->stream_buffers[i]
470 * cx->stream_buf_size[i]/(1024 * 1024);
474 /* All other streams have stream_buf_size in kB at this point */
475 if (cx->stream_buffers[i] < 0) {
476 cx->stream_buffers[i] = cx->options.megabytes[i] * 1024
477 / cx->stream_buf_size[i];
479 /* N.B. This might round down to 0 */
480 cx->options.megabytes[i] =
481 cx->stream_buffers[i] * cx->stream_buf_size[i] / 1024;
483 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
486 cx->options.cardtype = cardtype[cx->instance];
487 cx->options.tuner = tuner[cx->instance];
488 cx->options.radio = radio[cx->instance];
490 cx->std = cx18_parse_std(cx);
491 if (cx->options.cardtype == -1) {
492 CX18_INFO("Ignore card\n");
495 cx->card = cx18_get_card(cx->options.cardtype - 1);
497 CX18_INFO("User specified %s card\n", cx->card->name);
498 else if (cx->options.cardtype != 0)
499 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
500 if (cx->card == NULL) {
501 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
502 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
503 CX18_INFO("Autodetected Hauppauge card\n");
506 if (cx->card == NULL) {
507 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
508 if (cx->card->pci_list == NULL)
510 for (j = 0; cx->card->pci_list[j].device; j++) {
511 if (cx->pci_dev->device !=
512 cx->card->pci_list[j].device)
514 if (cx->pci_dev->subsystem_vendor !=
515 cx->card->pci_list[j].subsystem_vendor)
517 if (cx->pci_dev->subsystem_device !=
518 cx->card->pci_list[j].subsystem_device)
520 CX18_INFO("Autodetected %s card\n", cx->card->name);
527 if (cx->card == NULL) {
528 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
529 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
530 cx->pci_dev->vendor, cx->pci_dev->device);
531 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
532 cx->pci_dev->subsystem_vendor,
533 cx->pci_dev->subsystem_device);
534 CX18_ERR("Defaulting to %s card\n", cx->card->name);
535 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
536 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
537 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
539 cx->v4l2_cap = cx->card->v4l2_capabilities;
540 cx->card_name = cx->card->name;
541 cx->card_i2c = cx->card->i2c;
544 /* Precondition: the cx18 structure has been memset to 0. Only
545 the dev and instance fields have been filled in.
546 No assumptions on the card type may be made here (see cx18_init_struct2
549 static int __devinit cx18_init_struct1(struct cx18 *cx)
553 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
555 mutex_init(&cx->serialize_lock);
556 mutex_init(&cx->i2c_bus_lock[0]);
557 mutex_init(&cx->i2c_bus_lock[1]);
558 mutex_init(&cx->gpio_lock);
559 mutex_init(&cx->epu2apu_mb_lock);
560 mutex_init(&cx->epu2cpu_mb_lock);
562 cx->work_queue = create_singlethread_workqueue(cx->v4l2_dev.name);
563 if (cx->work_queue == NULL) {
564 CX18_ERR("Unable to create work hander thread\n");
568 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++) {
569 cx->epu_work_order[i].cx = cx;
570 cx->epu_work_order[i].str = cx->epu_debug_str;
571 INIT_WORK(&cx->epu_work_order[i].work, cx18_epu_work_handler);
574 /* start counting open_id at 1 */
577 /* Initial settings */
578 cx2341x_fill_defaults(&cx->params);
579 cx->temporal_strength = cx->params.video_temporal_filter;
580 cx->spatial_strength = cx->params.video_spatial_filter;
581 cx->filter_mode = cx->params.video_spatial_filter_mode |
582 (cx->params.video_temporal_filter_mode << 1) |
583 (cx->params.video_median_filter_type << 2);
584 cx->params.port = CX2341X_PORT_MEMORY;
585 cx->params.capabilities =
586 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_AC3 | CX2341X_CAP_HAS_SLICED_VBI;
587 init_waitqueue_head(&cx->cap_w);
588 init_waitqueue_head(&cx->mb_apu_waitq);
589 init_waitqueue_head(&cx->mb_cpu_waitq);
590 init_waitqueue_head(&cx->dma_waitq);
593 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
594 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
599 /* Second initialization part. Here the card type has been
601 static void __devinit cx18_init_struct2(struct cx18 *cx)
605 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
606 if (cx->card->video_inputs[i].video_type == 0)
609 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
610 if (cx->card->audio_inputs[i].audio_type == 0)
612 cx->nof_audio_inputs = i;
614 /* Find tuner input */
615 for (i = 0; i < cx->nof_inputs; i++) {
616 if (cx->card->video_inputs[i].video_type ==
617 CX18_CARD_INPUT_VID_TUNER)
620 if (i == cx->nof_inputs)
622 cx->active_input = i;
623 cx->audio_input = cx->card->video_inputs[i].audio_index;
626 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
627 const struct pci_device_id *pci_id)
630 unsigned char pci_latency;
632 CX18_DEBUG_INFO("Enabling pci device\n");
634 if (pci_enable_device(pci_dev)) {
635 CX18_ERR("Can't enable device %d!\n", cx->instance);
638 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
639 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
642 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
643 CX18_ERR("Cannot request encoder memory region, card %d\n",
648 /* Enable bus mastering and memory mapped IO for the CX23418 */
649 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
650 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
651 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
653 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
654 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
656 if (pci_latency < 64 && cx18_pci_latency) {
657 CX18_INFO("Unreasonably low latency timer, "
658 "setting to 64 (was %d)\n", pci_latency);
659 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
660 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
663 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
664 "irq: %d, latency: %d, memory: 0x%lx\n",
665 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
666 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
667 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
673 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
674 const char *name, u32 id)
678 if (request_module("%s", name) != 0) {
679 CX18_ERR("Failed to load module %s\n", name);
682 CX18_DEBUG_INFO("Loaded module %s\n", name);
687 static void cx18_load_and_init_modules(struct cx18 *cx)
689 u32 hw = cx->card->hw_all;
694 #ifdef CONFIG_MEDIA_TUNER_MODULE
695 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
697 #ifdef CONFIG_VIDEO_CS5345_MODULE
698 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
702 /* check which i2c devices are actually found */
703 for (i = 0; i < 32; i++) {
708 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
709 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
710 /* These 'devices' do not use i2c probing */
711 cx->hw_flags |= device;
714 cx18_i2c_register(cx, i);
715 if (cx18_i2c_hw_addr(cx, device) > 0)
716 cx->hw_flags |= device;
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 retval = cx18_av_probe(cx, &cx->sd_av);
810 CX18_ERR("Could not register A/V decoder subdevice\n");
813 /* Initialize the A/V decoder PLLs to sane defaults */
814 v4l2_subdev_call(cx->sd_av, core, init, (u32) CX18_AV_INIT_PLLS);
817 CX18_DEBUG_INFO("activating i2c...\n");
818 retval = init_cx18_i2c(cx);
820 CX18_ERR("Could not initialize i2c\n");
824 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
825 /* Based on the model number the cardtype may be changed.
826 The PCI IDs are not always reliable. */
827 cx18_process_eeprom(cx);
829 if (cx->card->comment)
830 CX18_INFO("%s", cx->card->comment);
831 if (cx->card->v4l2_capabilities == 0) {
835 cx18_init_memory(cx);
839 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
840 IRQF_SHARED | IRQF_DISABLED,
841 cx->v4l2_dev.name, (void *)cx);
843 CX18_ERR("Failed to register irq %d\n", retval);
848 cx->std = V4L2_STD_NTSC_M;
850 if (cx->options.tuner == -1) {
851 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
852 if ((cx->std & cx->card->tuners[i].std) == 0)
854 cx->options.tuner = cx->card->tuners[i].tuner;
858 /* if no tuner was found, then pick the first tuner in the card list */
859 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
860 cx->std = cx->card->tuners[0].std;
861 if (cx->std & V4L2_STD_PAL)
862 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
863 else if (cx->std & V4L2_STD_NTSC)
864 cx->std = V4L2_STD_NTSC_M;
865 else if (cx->std & V4L2_STD_SECAM)
866 cx->std = V4L2_STD_SECAM_L;
867 cx->options.tuner = cx->card->tuners[0].tuner;
869 if (cx->options.radio == -1)
870 cx->options.radio = (cx->card->radio_input.audio_type != 0);
872 /* The card is now fully identified, continue with card-specific
874 cx18_init_struct2(cx);
876 cx18_load_and_init_modules(cx);
878 if (cx->std & V4L2_STD_525_60) {
885 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
887 if (cx->options.radio > 0)
888 cx->v4l2_cap |= V4L2_CAP_RADIO;
890 if (cx->options.tuner > -1) {
891 struct tuner_setup setup;
893 setup.addr = ADDR_UNSET;
894 setup.type = cx->options.tuner;
895 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
896 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
897 cx18_reset_tuner_gpio : NULL;
898 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
899 if (setup.type == TUNER_XC2028) {
900 static struct xc2028_ctrl ctrl = {
901 .fname = XC2028_DEFAULT_FIRMWARE,
904 struct v4l2_priv_tun_config cfg = {
905 .tuner = cx->options.tuner,
908 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
912 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
914 cx->tuner_std = cx->std;
916 retval = cx18_streams_setup(cx);
918 CX18_ERR("Error %d setting up streams\n", retval);
921 retval = cx18_streams_register(cx);
923 CX18_ERR("Error %d registering devices\n", retval);
927 CX18_INFO("Initialized card: %s\n", cx->card_name);
931 cx18_streams_cleanup(cx, 1);
933 free_irq(cx->pci_dev->irq, (void *)cx);
939 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
941 destroy_workqueue(cx->work_queue);
945 CX18_ERR("Error %d on initialization\n", retval);
947 v4l2_device_unregister(&cx->v4l2_dev);
952 int cx18_init_on_first_open(struct cx18 *cx)
955 int fw_retry_count = 3;
956 struct v4l2_frequency vf;
957 struct cx18_open_id fh;
961 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
964 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
967 while (--fw_retry_count > 0) {
969 if (cx18_firmware_init(cx) == 0)
971 if (fw_retry_count > 1)
972 CX18_WARN("Retry loading firmware\n");
975 if (fw_retry_count == 0) {
976 set_bit(CX18_F_I_FAILED, &cx->i_flags);
979 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
982 * Init the firmware twice to work around a silicon bug
983 * with the digital TS.
985 * The second firmware load requires us to normalize the APU state,
986 * or the audio for the first analog capture will be badly incorrect.
988 * I can't seem to call APU_RESETAI and have it succeed without the
989 * APU capturing audio, so we start and stop it here to do the reset
992 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
993 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
994 cx18_vapi(cx, CX18_APU_RESETAI, 0);
995 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
998 while (--fw_retry_count > 0) {
1000 if (cx18_firmware_init(cx) == 0)
1002 if (fw_retry_count > 1)
1003 CX18_WARN("Retry loading firmware\n");
1006 if (fw_retry_count == 0) {
1007 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1012 * The second firmware load requires us to normalize the APU state,
1013 * or the audio for the first analog capture will be badly incorrect.
1015 * I can't seem to call APU_RESETAI and have it succeed without the
1016 * APU capturing audio, so we start and stop it here to do the reset
1019 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1020 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1021 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1022 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1024 /* Init the A/V decoder, if it hasn't been already */
1025 v4l2_subdev_call(cx->sd_av, core, init, (u32) CX18_AV_INIT_NORMAL);
1028 vf.type = V4L2_TUNER_ANALOG_TV;
1029 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1031 /* Set initial frequency. For PAL/SECAM broadcasts no
1032 'default' channel exists AFAIK. */
1033 if (cx->std == V4L2_STD_NTSC_M_JP)
1034 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1035 else if (cx->std & V4L2_STD_NTSC_M)
1036 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1038 video_input = cx->active_input;
1039 cx->active_input++; /* Force update of input */
1040 cx18_s_input(NULL, &fh, video_input);
1042 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1044 cx->std++; /* Force full standard initialization */
1045 cx18_s_std(NULL, &fh, &cx->tuner_std);
1046 cx18_s_frequency(NULL, &fh, &vf);
1050 static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1053 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1054 cancel_work_sync(&cx->epu_work_order[i].work);
1057 static void cx18_remove(struct pci_dev *pci_dev)
1059 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1060 struct cx18 *cx = to_cx18(v4l2_dev);
1062 CX18_DEBUG_INFO("Removing Card\n");
1064 /* Stop all captures */
1065 CX18_DEBUG_INFO("Stopping all streams\n");
1066 if (atomic_read(&cx->tot_capturing) > 0)
1067 cx18_stop_all_captures(cx);
1070 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1071 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1073 cx18_halt_firmware(cx);
1075 cx18_cancel_epu_work_orders(cx);
1077 destroy_workqueue(cx->work_queue);
1079 cx18_streams_cleanup(cx, 1);
1083 free_irq(cx->pci_dev->irq, (void *)cx);
1087 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1089 pci_disable_device(cx->pci_dev);
1090 /* FIXME - we leak cx->vbi.sliced_mpeg_data[i] allocations */
1092 CX18_INFO("Removed %s\n", cx->card_name);
1094 v4l2_device_unregister(v4l2_dev);
1098 /* define a pci_driver for card detection */
1099 static struct pci_driver cx18_pci_driver = {
1101 .id_table = cx18_pci_tbl,
1102 .probe = cx18_probe,
1103 .remove = cx18_remove,
1106 static int module_start(void)
1108 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1110 /* Validate parameters */
1111 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1112 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1113 CX18_MAX_CARDS - 1);
1117 if (cx18_debug < 0 || cx18_debug > 511) {
1119 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1122 if (pci_register_driver(&cx18_pci_driver)) {
1123 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1126 printk(KERN_INFO "cx18: End initialization\n");
1130 static void module_cleanup(void)
1132 pci_unregister_driver(&cx18_pci_driver);
1135 module_init(module_start);
1136 module_exit(module_cleanup);