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;
624 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
625 cx->av_state.aud_input = CX18_AV_AUDIO8;
626 cx->av_state.audclk_freq = 48000;
627 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
628 cx->av_state.slicer_line_delay = 0;
629 cx->av_state.slicer_line_offset =
630 (10 + cx->av_state.slicer_line_delay - 2);
633 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
634 const struct pci_device_id *pci_id)
637 unsigned char pci_latency;
639 CX18_DEBUG_INFO("Enabling pci device\n");
641 if (pci_enable_device(pci_dev)) {
642 CX18_ERR("Can't enable device %d!\n", cx->instance);
645 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
646 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
649 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
650 CX18_ERR("Cannot request encoder memory region, card %d\n",
655 /* Enable bus mastering and memory mapped IO for the CX23418 */
656 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
657 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
658 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
660 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
661 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
663 if (pci_latency < 64 && cx18_pci_latency) {
664 CX18_INFO("Unreasonably low latency timer, "
665 "setting to 64 (was %d)\n", pci_latency);
666 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
667 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
670 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
671 "irq: %d, latency: %d, memory: 0x%lx\n",
672 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
673 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
674 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
680 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
681 const char *name, u32 id)
685 if (request_module("%s", name) != 0) {
686 CX18_ERR("Failed to load module %s\n", name);
689 CX18_DEBUG_INFO("Loaded module %s\n", name);
694 static void cx18_load_and_init_modules(struct cx18 *cx)
696 u32 hw = cx->card->hw_all;
701 #ifdef CONFIG_MEDIA_TUNER_MODULE
702 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
704 #ifdef CONFIG_VIDEO_CS5345_MODULE
705 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
709 /* check which i2c devices are actually found */
710 for (i = 0; i < 32; i++) {
715 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
716 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
717 /* These 'devices' do not use i2c probing */
718 cx->hw_flags |= device;
721 cx18_i2c_register(cx, i);
722 if (cx18_i2c_hw_addr(cx, device) > 0)
723 cx->hw_flags |= device;
729 static int __devinit cx18_probe(struct pci_dev *pci_dev,
730 const struct pci_device_id *pci_id)
737 /* FIXME - module parameter arrays constrain max instances */
738 i = atomic_inc_return(&cx18_instance) - 1;
739 if (i >= CX18_MAX_CARDS) {
740 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
741 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
745 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
747 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
751 cx->pci_dev = pci_dev;
754 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
756 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
761 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
763 CX18_INFO("Initializing card %d\n", cx->instance);
765 cx18_process_options(cx);
766 if (cx->options.cardtype == -1) {
770 if (cx18_init_struct1(cx)) {
775 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
777 /* PCI Device Setup */
778 retval = cx18_setup_pci(cx, pci_dev, pci_id);
783 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
784 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
785 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
788 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
789 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
793 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
794 devtype = cx18_read_reg(cx, 0xC72028);
795 switch (devtype & 0xff000000) {
797 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
800 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
803 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
807 cx18_init_power(cx, 1);
808 cx18_init_memory(cx);
810 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
816 CX18_DEBUG_INFO("activating i2c...\n");
817 retval = init_cx18_i2c(cx);
819 CX18_ERR("Could not initialize i2c\n");
823 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
824 /* Based on the model number the cardtype may be changed.
825 The PCI IDs are not always reliable. */
826 cx18_process_eeprom(cx);
828 if (cx->card->comment)
829 CX18_INFO("%s", cx->card->comment);
830 if (cx->card->v4l2_capabilities == 0) {
834 cx18_init_memory(cx);
838 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
839 IRQF_SHARED | IRQF_DISABLED,
840 cx->v4l2_dev.name, (void *)cx);
842 CX18_ERR("Failed to register irq %d\n", retval);
847 cx->std = V4L2_STD_NTSC_M;
849 if (cx->options.tuner == -1) {
850 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
851 if ((cx->std & cx->card->tuners[i].std) == 0)
853 cx->options.tuner = cx->card->tuners[i].tuner;
857 /* if no tuner was found, then pick the first tuner in the card list */
858 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
859 cx->std = cx->card->tuners[0].std;
860 if (cx->std & V4L2_STD_PAL)
861 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
862 else if (cx->std & V4L2_STD_NTSC)
863 cx->std = V4L2_STD_NTSC_M;
864 else if (cx->std & V4L2_STD_SECAM)
865 cx->std = V4L2_STD_SECAM_L;
866 cx->options.tuner = cx->card->tuners[0].tuner;
868 if (cx->options.radio == -1)
869 cx->options.radio = (cx->card->radio_input.audio_type != 0);
871 /* The card is now fully identified, continue with card-specific
873 cx18_init_struct2(cx);
875 cx18_load_and_init_modules(cx);
877 if (cx->std & V4L2_STD_525_60) {
884 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
886 if (cx->options.radio > 0)
887 cx->v4l2_cap |= V4L2_CAP_RADIO;
889 if (cx->options.tuner > -1) {
890 struct tuner_setup setup;
892 setup.addr = ADDR_UNSET;
893 setup.type = cx->options.tuner;
894 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
895 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
896 cx18_reset_tuner_gpio : NULL;
897 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
898 if (setup.type == TUNER_XC2028) {
899 static struct xc2028_ctrl ctrl = {
900 .fname = XC2028_DEFAULT_FIRMWARE,
903 struct v4l2_priv_tun_config cfg = {
904 .tuner = cx->options.tuner,
907 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
911 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
913 cx->tuner_std = cx->std;
915 retval = cx18_streams_setup(cx);
917 CX18_ERR("Error %d setting up streams\n", retval);
920 retval = cx18_streams_register(cx);
922 CX18_ERR("Error %d registering devices\n", retval);
926 CX18_INFO("Initialized card: %s\n", cx->card_name);
930 cx18_streams_cleanup(cx, 1);
932 free_irq(cx->pci_dev->irq, (void *)cx);
938 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
940 destroy_workqueue(cx->work_queue);
944 CX18_ERR("Error %d on initialization\n", retval);
946 v4l2_device_unregister(&cx->v4l2_dev);
951 int cx18_init_on_first_open(struct cx18 *cx)
954 int fw_retry_count = 3;
955 struct v4l2_frequency vf;
956 struct cx18_open_id fh;
960 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
963 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
966 while (--fw_retry_count > 0) {
968 if (cx18_firmware_init(cx) == 0)
970 if (fw_retry_count > 1)
971 CX18_WARN("Retry loading firmware\n");
974 if (fw_retry_count == 0) {
975 set_bit(CX18_F_I_FAILED, &cx->i_flags);
978 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
981 * Init the firmware twice to work around a silicon bug
982 * with the digital TS.
984 * The second firmware load requires us to normalize the APU state,
985 * or the audio for the first analog capture will be badly incorrect.
987 * I can't seem to call APU_RESETAI and have it succeed without the
988 * APU capturing audio, so we start and stop it here to do the reset
991 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
992 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
993 cx18_vapi(cx, CX18_APU_RESETAI, 0);
994 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
997 while (--fw_retry_count > 0) {
999 if (cx18_firmware_init(cx) == 0)
1001 if (fw_retry_count > 1)
1002 CX18_WARN("Retry loading firmware\n");
1005 if (fw_retry_count == 0) {
1006 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1011 * The second firmware load requires us to normalize the APU state,
1012 * or the audio for the first analog capture will be badly incorrect.
1014 * I can't seem to call APU_RESETAI and have it succeed without the
1015 * APU capturing audio, so we start and stop it here to do the reset
1018 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1019 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1020 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1021 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1024 vf.type = V4L2_TUNER_ANALOG_TV;
1025 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1027 /* Set initial frequency. For PAL/SECAM broadcasts no
1028 'default' channel exists AFAIK. */
1029 if (cx->std == V4L2_STD_NTSC_M_JP)
1030 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1031 else if (cx->std & V4L2_STD_NTSC_M)
1032 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1034 video_input = cx->active_input;
1035 cx->active_input++; /* Force update of input */
1036 cx18_s_input(NULL, &fh, video_input);
1038 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1040 cx->std++; /* Force full standard initialization */
1041 cx18_s_std(NULL, &fh, &cx->tuner_std);
1042 cx18_s_frequency(NULL, &fh, &vf);
1046 static void cx18_cancel_epu_work_orders(struct cx18 *cx)
1049 for (i = 0; i < CX18_MAX_EPU_WORK_ORDERS; i++)
1050 cancel_work_sync(&cx->epu_work_order[i].work);
1053 static void cx18_remove(struct pci_dev *pci_dev)
1055 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1056 struct cx18 *cx = to_cx18(v4l2_dev);
1058 CX18_DEBUG_INFO("Removing Card\n");
1060 /* Stop all captures */
1061 CX18_DEBUG_INFO("Stopping all streams\n");
1062 if (atomic_read(&cx->tot_capturing) > 0)
1063 cx18_stop_all_captures(cx);
1066 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1067 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1069 cx18_halt_firmware(cx);
1071 cx18_cancel_epu_work_orders(cx);
1073 destroy_workqueue(cx->work_queue);
1075 cx18_streams_cleanup(cx, 1);
1079 free_irq(cx->pci_dev->irq, (void *)cx);
1083 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1085 pci_disable_device(cx->pci_dev);
1086 /* FIXME - we leak cx->vbi.sliced_mpeg_data[i] allocations */
1088 CX18_INFO("Removed %s\n", cx->card_name);
1090 v4l2_device_unregister(v4l2_dev);
1094 /* define a pci_driver for card detection */
1095 static struct pci_driver cx18_pci_driver = {
1097 .id_table = cx18_pci_tbl,
1098 .probe = cx18_probe,
1099 .remove = cx18_remove,
1102 static int module_start(void)
1104 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
1106 /* Validate parameters */
1107 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1108 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1109 CX18_MAX_CARDS - 1);
1113 if (cx18_debug < 0 || cx18_debug > 511) {
1115 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1118 if (pci_register_driver(&cx18_pci_driver)) {
1119 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1122 printk(KERN_INFO "cx18: End initialization\n");
1126 static void module_cleanup(void)
1128 pci_unregister_driver(&cx18_pci_driver);
1131 module_init(module_start);
1132 module_exit(module_cleanup);