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@md.metrocast.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-queue.h"
34 #include "cx18-streams.h"
35 #include "cx18-av-core.h"
37 #include "cx18-mailbox.h"
38 #include "cx18-ioctl.h"
39 #include "tuner-xc2028.h"
41 #include <media/tveeprom.h>
43 /* If you have already X v4l cards, then set this to X. This way
44 the device numbers stay matched. Example: you have a WinTV card
45 without radio and a Compro H900 with. Normally this would give a
46 video1 device together with a radio0 device for the Compro. By
47 setting this to 1 you ensure that radio0 is now also radio1. */
50 /* Callback for registering extensions */
51 int (*cx18_ext_init)(struct cx18 *);
52 EXPORT_SYMBOL(cx18_ext_init);
54 /* add your revision and whatnot here */
55 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
56 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
57 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
61 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
63 static atomic_t cx18_instance = ATOMIC_INIT(0);
65 /* Parameter declarations */
66 static int cardtype[CX18_MAX_CARDS];
67 static int tuner[CX18_MAX_CARDS] = { -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 -1, -1, -1, -1, -1, -1, -1, -1 };
71 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
72 -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1,
74 -1, -1, -1, -1, -1, -1, -1, -1 };
75 static unsigned cardtype_c = 1;
76 static unsigned tuner_c = 1;
77 static unsigned radio_c = 1;
78 static char pal[] = "--";
79 static char secam[] = "--";
80 static char ntsc[] = "-";
83 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
84 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
85 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
86 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
87 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
88 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
90 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
91 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
92 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
93 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
94 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
96 static int enc_ts_bufs = -1;
97 static int enc_mpg_bufs = -1;
98 static int enc_idx_bufs = CX18_MAX_FW_MDLS_PER_STREAM;
99 static int enc_yuv_bufs = -1;
100 static int enc_vbi_bufs = -1;
101 static int enc_pcm_bufs = -1;
104 static int cx18_pci_latency = 1;
106 static int mmio_ndelay;
107 static int retry_mmio = 1;
111 module_param_array(tuner, int, &tuner_c, 0644);
112 module_param_array(radio, bool, &radio_c, 0644);
113 module_param_array(cardtype, int, &cardtype_c, 0644);
114 module_param_string(pal, pal, sizeof(pal), 0644);
115 module_param_string(secam, secam, sizeof(secam), 0644);
116 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
117 module_param_named(debug, cx18_debug, int, 0644);
118 module_param(mmio_ndelay, int, 0644);
119 module_param(retry_mmio, int, 0644);
120 module_param(cx18_pci_latency, int, 0644);
121 module_param(cx18_first_minor, int, 0644);
123 module_param(enc_ts_buffers, int, 0644);
124 module_param(enc_mpg_buffers, int, 0644);
125 module_param(enc_idx_buffers, int, 0644);
126 module_param(enc_yuv_buffers, int, 0644);
127 module_param(enc_vbi_buffers, int, 0644);
128 module_param(enc_pcm_buffers, int, 0644);
130 module_param(enc_ts_bufsize, int, 0644);
131 module_param(enc_mpg_bufsize, int, 0644);
132 module_param(enc_idx_bufsize, int, 0644);
133 module_param(enc_yuv_bufsize, int, 0644);
134 module_param(enc_pcm_bufsize, int, 0644);
136 module_param(enc_ts_bufs, int, 0644);
137 module_param(enc_mpg_bufs, int, 0644);
138 module_param(enc_idx_bufs, int, 0644);
139 module_param(enc_yuv_bufs, int, 0644);
140 module_param(enc_vbi_bufs, int, 0644);
141 module_param(enc_pcm_bufs, int, 0644);
143 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
144 "\t\t\tsee tuner.h for values");
145 MODULE_PARM_DESC(radio,
146 "Enable or disable the radio. Use only if autodetection\n"
147 "\t\t\tfails. 0 = disable, 1 = enable");
148 MODULE_PARM_DESC(cardtype,
149 "Only use this option if your card is not detected properly.\n"
150 "\t\tSpecify card type:\n"
151 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
152 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
153 "\t\t\t 3 = Compro VideoMate H900\n"
154 "\t\t\t 4 = Yuan MPC718\n"
155 "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
156 "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
157 "\t\t\t 7 = Leadtek WinFast PVR2100\n"
158 "\t\t\t 8 = Leadtek WinFast DVR3100 H\n"
159 "\t\t\t 9 = GoTView PCI DVD3 Hybrid\n"
160 "\t\t\t 0 = Autodetect (default)\n"
161 "\t\t\t-1 = Ignore this card\n\t\t");
162 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
163 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
164 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
165 MODULE_PARM_DESC(debug,
166 "Debug level (bitmask). Default: 0\n"
167 "\t\t\t 1/0x0001: warning\n"
168 "\t\t\t 2/0x0002: info\n"
169 "\t\t\t 4/0x0004: mailbox\n"
170 "\t\t\t 8/0x0008: dma\n"
171 "\t\t\t 16/0x0010: ioctl\n"
172 "\t\t\t 32/0x0020: file\n"
173 "\t\t\t 64/0x0040: i2c\n"
174 "\t\t\t128/0x0080: irq\n"
175 "\t\t\t256/0x0100: high volume\n");
176 MODULE_PARM_DESC(cx18_pci_latency,
177 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
178 "\t\t\tDefault: Yes");
179 MODULE_PARM_DESC(retry_mmio,
180 "(Deprecated) MMIO writes are now always checked and retried\n"
181 "\t\t\tEffectively: 1 [Yes]");
182 MODULE_PARM_DESC(mmio_ndelay,
183 "(Deprecated) MMIO accesses are now never purposely delayed\n"
184 "\t\t\tEffectively: 0 ns");
185 MODULE_PARM_DESC(enc_ts_buffers,
186 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
187 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
188 MODULE_PARM_DESC(enc_ts_bufsize,
189 "Size of an encoder TS buffer (kB)\n"
190 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
191 MODULE_PARM_DESC(enc_ts_bufs,
192 "Number of encoder TS buffers\n"
193 "\t\t\tDefault is computed from other enc_ts_* parameters");
194 MODULE_PARM_DESC(enc_mpg_buffers,
195 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
196 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
197 MODULE_PARM_DESC(enc_mpg_bufsize,
198 "Size of an encoder MPG buffer (kB)\n"
199 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
200 MODULE_PARM_DESC(enc_mpg_bufs,
201 "Number of encoder MPG buffers\n"
202 "\t\t\tDefault is computed from other enc_mpg_* parameters");
203 MODULE_PARM_DESC(enc_idx_buffers,
204 "(Deprecated) Encoder IDX buffer memory (MB)\n"
205 "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
206 "\t\t\tDefault: 1 [Enabled]");
207 MODULE_PARM_DESC(enc_idx_bufsize,
208 "Size of an encoder IDX buffer (kB)\n"
209 "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
210 "\t\t\t(multiples of size required for 64 index entries)\n"
212 MODULE_PARM_DESC(enc_idx_bufs,
213 "Number of encoder IDX buffers\n"
214 "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM));
215 MODULE_PARM_DESC(enc_yuv_buffers,
216 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
217 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
218 MODULE_PARM_DESC(enc_yuv_bufsize,
219 "Size of an encoder YUV buffer (kB)\n"
220 "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
221 "\t\t\t(multiples of size required for 32 screen lines)\n"
222 "\t\t\tDefault: 102");
223 MODULE_PARM_DESC(enc_yuv_bufs,
224 "Number of encoder YUV buffers\n"
225 "\t\t\tDefault is computed from other enc_yuv_* parameters");
226 MODULE_PARM_DESC(enc_vbi_buffers,
227 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
228 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
229 MODULE_PARM_DESC(enc_vbi_bufs,
230 "Number of encoder VBI buffers\n"
231 "\t\t\tDefault is computed from enc_vbi_buffers");
232 MODULE_PARM_DESC(enc_pcm_buffers,
233 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
234 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
235 MODULE_PARM_DESC(enc_pcm_bufsize,
236 "Size of an encoder PCM buffer (kB)\n"
237 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
238 MODULE_PARM_DESC(enc_pcm_bufs,
239 "Number of encoder PCM buffers\n"
240 "\t\t\tDefault is computed from other enc_pcm_* parameters");
242 MODULE_PARM_DESC(cx18_first_minor,
243 "Set device node number assigned to first card");
245 MODULE_AUTHOR("Hans Verkuil");
246 MODULE_DESCRIPTION("CX23418 driver");
247 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
248 MODULE_LICENSE("GPL");
250 MODULE_VERSION(CX18_VERSION);
252 #if defined(CONFIG_MODULES) && defined(MODULE)
253 static void request_module_async(struct work_struct *work)
255 struct cx18 *dev = container_of(work, struct cx18, request_module_wk);
257 /* Make sure cx18-alsa module is loaded */
258 request_module("cx18-alsa");
260 /* Initialize cx18-alsa for this instance of the cx18 device */
261 if (cx18_ext_init != NULL)
265 static void request_modules(struct cx18 *dev)
267 INIT_WORK(&dev->request_module_wk, request_module_async);
268 schedule_work(&dev->request_module_wk);
271 static void flush_request_modules(struct cx18 *dev)
273 flush_work_sync(&dev->request_module_wk);
276 #define request_modules(dev)
277 #define flush_request_modules(dev)
278 #endif /* CONFIG_MODULES */
280 /* Generic utility functions */
281 int cx18_msleep_timeout(unsigned int msecs, int intr)
283 long int timeout = msecs_to_jiffies(msecs);
287 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
288 timeout = schedule_timeout(timeout);
289 sig = intr ? signal_pending(current) : 0;
290 } while (!sig && timeout);
294 /* Release ioremapped memory */
295 static void cx18_iounmap(struct cx18 *cx)
300 /* Release io memory */
301 if (cx->enc_mem != NULL) {
302 CX18_DEBUG_INFO("releasing enc_mem\n");
303 iounmap(cx->enc_mem);
308 static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
312 CX18_INFO("eeprom dump:\n");
313 for (i = 0; i < len; i++) {
315 CX18_INFO("eeprom %02x:", i);
316 printk(KERN_CONT " %02x", eedata[i]);
318 printk(KERN_CONT "\n");
322 /* Hauppauge card? get values from tveeprom */
323 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
328 memset(&c, 0, sizeof(c));
329 strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
330 c.adapter = &cx->i2c_adap[0];
333 memset(tv, 0, sizeof(*tv));
334 if (tveeprom_read(&c, eedata, sizeof(eedata)))
337 switch (cx->card->type) {
338 case CX18_CARD_HVR_1600_ESMT:
339 case CX18_CARD_HVR_1600_SAMSUNG:
340 tveeprom_hauppauge_analog(&c, tv, eedata);
342 case CX18_CARD_YUAN_MPC718:
343 case CX18_CARD_GOTVIEW_PCI_DVD3:
345 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
346 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
347 eedata[2], eedata[1], eedata[4], eedata[3]);
350 tv->model = 0xffffffff;
351 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
356 static void cx18_process_eeprom(struct cx18 *cx)
360 cx18_read_eeprom(cx, &tv);
362 /* Many thanks to Steven Toth from Hauppauge for providing the
364 /* Note: the Samsung memory models cannot be reliably determined
365 from the model number. Use the cardtype module option if you
366 have one of these preproduction models. */
368 case 74000 ... 74999:
369 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
374 CX18_INFO("Unknown EEPROM encoding\n");
377 CX18_ERR("Invalid EEPROM\n");
380 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
381 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
385 cx->v4l2_cap = cx->card->v4l2_capabilities;
386 cx->card_name = cx->card->name;
387 cx->card_i2c = cx->card->i2c;
389 CX18_INFO("Autodetected %s\n", cx->card_name);
391 if (tv.tuner_type == TUNER_ABSENT)
392 CX18_ERR("tveeprom cannot autodetect tuner!\n");
394 if (cx->options.tuner == -1)
395 cx->options.tuner = tv.tuner_type;
396 if (cx->options.radio == -1)
397 cx->options.radio = (tv.has_radio != 0);
400 /* user specified tuner standard */
403 /* autodetect tuner standard */
404 if (tv.tuner_formats & V4L2_STD_PAL) {
405 CX18_DEBUG_INFO("PAL tuner detected\n");
406 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
407 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
408 CX18_DEBUG_INFO("NTSC tuner detected\n");
409 cx->std |= V4L2_STD_NTSC_M;
410 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
411 CX18_DEBUG_INFO("SECAM tuner detected\n");
412 cx->std |= V4L2_STD_SECAM_L;
414 CX18_INFO("No tuner detected, default to NTSC-M\n");
415 cx->std |= V4L2_STD_NTSC_M;
419 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
423 return V4L2_STD_PAL_60;
428 return V4L2_STD_PAL_BG;
431 return V4L2_STD_PAL_H;
434 if (pal[1] == 'c' || pal[1] == 'C')
435 return V4L2_STD_PAL_Nc;
436 return V4L2_STD_PAL_N;
439 return V4L2_STD_PAL_I;
444 return V4L2_STD_PAL_DK;
447 return V4L2_STD_PAL_M;
451 CX18_WARN("pal= argument not recognised\n");
462 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
467 return V4L2_STD_SECAM_DK;
470 if (secam[1] == 'C' || secam[1] == 'c')
471 return V4L2_STD_SECAM_LC;
472 return V4L2_STD_SECAM_L;
476 CX18_WARN("secam= argument not recognised\n");
483 return V4L2_STD_NTSC_M;
486 return V4L2_STD_NTSC_M_JP;
489 return V4L2_STD_NTSC_M_KR;
493 CX18_WARN("ntsc= argument not recognised\n");
501 static void cx18_process_options(struct cx18 *cx)
505 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
506 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
507 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
508 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
509 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
510 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
511 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
513 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
514 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
515 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
516 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
517 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
518 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
519 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
521 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
522 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
523 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
524 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
525 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
526 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
527 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
529 /* Ensure stream_buffers & stream_buf_size are valid */
530 for (i = 0; i < CX18_MAX_STREAMS; i++) {
531 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
532 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
533 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
534 cx->options.megabytes[i] = 0;
535 cx->stream_buffers[i] = 0;
536 cx->stream_buf_size[i] = 0;
540 * YUV is a special case where the stream_buf_size needs to be
541 * an integral multiple of 33.75 kB (storage for 32 screens
542 * lines to maintain alignment in case of lost buffers).
544 * IDX is a special case where the stream_buf_size should be
545 * an integral multiple of 1.5 kB (storage for 64 index entries
546 * to maintain alignment in case of lost buffers).
549 if (i == CX18_ENC_STREAM_TYPE_YUV) {
550 cx->stream_buf_size[i] *= 1024;
551 cx->stream_buf_size[i] -=
552 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
554 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
555 cx->stream_buf_size[i] =
556 CX18_UNIT_ENC_YUV_BUFSIZE;
557 } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
558 cx->stream_buf_size[i] *= 1024;
559 cx->stream_buf_size[i] -=
560 (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
562 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
563 cx->stream_buf_size[i] =
564 CX18_UNIT_ENC_IDX_BUFSIZE;
567 * YUV and IDX are special cases where the stream_buf_size is
569 * VBI is a special case where the stream_buf_size is fixed
570 * and already in bytes
572 if (i == CX18_ENC_STREAM_TYPE_VBI ||
573 i == CX18_ENC_STREAM_TYPE_YUV ||
574 i == CX18_ENC_STREAM_TYPE_IDX) {
575 if (cx->stream_buffers[i] < 0) {
576 cx->stream_buffers[i] =
577 cx->options.megabytes[i] * 1024 * 1024
578 / cx->stream_buf_size[i];
580 /* N.B. This might round down to 0 */
581 cx->options.megabytes[i] =
582 cx->stream_buffers[i]
583 * cx->stream_buf_size[i]/(1024 * 1024);
586 /* All other streams have stream_buf_size in kB here */
587 if (cx->stream_buffers[i] < 0) {
588 cx->stream_buffers[i] =
589 cx->options.megabytes[i] * 1024
590 / cx->stream_buf_size[i];
592 /* N.B. This might round down to 0 */
593 cx->options.megabytes[i] =
594 cx->stream_buffers[i]
595 * cx->stream_buf_size[i] / 1024;
597 /* convert from kB to bytes */
598 cx->stream_buf_size[i] *= 1024;
600 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
601 "%d bytes\n", i, cx->options.megabytes[i],
602 cx->stream_buffers[i], cx->stream_buf_size[i]);
605 cx->options.cardtype = cardtype[cx->instance];
606 cx->options.tuner = tuner[cx->instance];
607 cx->options.radio = radio[cx->instance];
609 cx->std = cx18_parse_std(cx);
610 if (cx->options.cardtype == -1) {
611 CX18_INFO("Ignore card\n");
614 cx->card = cx18_get_card(cx->options.cardtype - 1);
616 CX18_INFO("User specified %s card\n", cx->card->name);
617 else if (cx->options.cardtype != 0)
618 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
619 if (cx->card == NULL) {
620 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
621 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
622 CX18_INFO("Autodetected Hauppauge card\n");
625 if (cx->card == NULL) {
626 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
627 if (cx->card->pci_list == NULL)
629 for (j = 0; cx->card->pci_list[j].device; j++) {
630 if (cx->pci_dev->device !=
631 cx->card->pci_list[j].device)
633 if (cx->pci_dev->subsystem_vendor !=
634 cx->card->pci_list[j].subsystem_vendor)
636 if (cx->pci_dev->subsystem_device !=
637 cx->card->pci_list[j].subsystem_device)
639 CX18_INFO("Autodetected %s card\n", cx->card->name);
646 if (cx->card == NULL) {
647 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
648 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
649 cx->pci_dev->vendor, cx->pci_dev->device);
650 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
651 cx->pci_dev->subsystem_vendor,
652 cx->pci_dev->subsystem_device);
653 CX18_ERR("Defaulting to %s card\n", cx->card->name);
654 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
655 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
656 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
658 cx->v4l2_cap = cx->card->v4l2_capabilities;
659 cx->card_name = cx->card->name;
660 cx->card_i2c = cx->card->i2c;
663 static int __devinit cx18_create_in_workq(struct cx18 *cx)
665 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
667 cx->in_work_queue = create_singlethread_workqueue(cx->in_workq_name);
668 if (cx->in_work_queue == NULL) {
669 CX18_ERR("Unable to create incoming mailbox handler thread\n");
675 static int __devinit cx18_create_out_workq(struct cx18 *cx)
677 snprintf(cx->out_workq_name, sizeof(cx->out_workq_name), "%s-out",
679 cx->out_work_queue = create_workqueue(cx->out_workq_name);
680 if (cx->out_work_queue == NULL) {
681 CX18_ERR("Unable to create outgoing mailbox handler threads\n");
687 static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
690 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
691 cx->in_work_order[i].cx = cx;
692 cx->in_work_order[i].str = cx->epu_debug_str;
693 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
697 /* Precondition: the cx18 structure has been memset to 0. Only
698 the dev and instance fields have been filled in.
699 No assumptions on the card type may be made here (see cx18_init_struct2
702 static int __devinit cx18_init_struct1(struct cx18 *cx)
706 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
708 mutex_init(&cx->serialize_lock);
709 mutex_init(&cx->gpio_lock);
710 mutex_init(&cx->epu2apu_mb_lock);
711 mutex_init(&cx->epu2cpu_mb_lock);
713 ret = cx18_create_out_workq(cx);
717 ret = cx18_create_in_workq(cx);
719 destroy_workqueue(cx->out_work_queue);
723 cx18_init_in_work_orders(cx);
725 /* start counting open_id at 1 */
728 /* Initial settings */
729 cx2341x_fill_defaults(&cx->params);
730 cx->temporal_strength = cx->params.video_temporal_filter;
731 cx->spatial_strength = cx->params.video_spatial_filter;
732 cx->filter_mode = cx->params.video_spatial_filter_mode |
733 (cx->params.video_temporal_filter_mode << 1) |
734 (cx->params.video_median_filter_type << 2);
735 cx->params.port = CX2341X_PORT_MEMORY;
736 cx->params.capabilities =
737 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
738 init_waitqueue_head(&cx->cap_w);
739 init_waitqueue_head(&cx->mb_apu_waitq);
740 init_waitqueue_head(&cx->mb_cpu_waitq);
741 init_waitqueue_head(&cx->dma_waitq);
744 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
745 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
747 /* IVTV style VBI insertion into MPEG streams */
748 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
749 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
750 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
751 list_add(&cx->vbi.sliced_mpeg_buf.list,
752 &cx->vbi.sliced_mpeg_mdl.buf_list);
756 /* Second initialization part. Here the card type has been
758 static void __devinit cx18_init_struct2(struct cx18 *cx)
762 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
763 if (cx->card->video_inputs[i].video_type == 0)
766 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
767 if (cx->card->audio_inputs[i].audio_type == 0)
769 cx->nof_audio_inputs = i;
771 /* Find tuner input */
772 for (i = 0; i < cx->nof_inputs; i++) {
773 if (cx->card->video_inputs[i].video_type ==
774 CX18_CARD_INPUT_VID_TUNER)
777 if (i == cx->nof_inputs)
779 cx->active_input = i;
780 cx->audio_input = cx->card->video_inputs[i].audio_index;
783 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
784 const struct pci_device_id *pci_id)
787 unsigned char pci_latency;
789 CX18_DEBUG_INFO("Enabling pci device\n");
791 if (pci_enable_device(pci_dev)) {
792 CX18_ERR("Can't enable device %d!\n", cx->instance);
795 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
796 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
799 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
800 CX18_ERR("Cannot request encoder memory region, card %d\n",
805 /* Enable bus mastering and memory mapped IO for the CX23418 */
806 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
807 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
808 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
810 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
811 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
813 if (pci_latency < 64 && cx18_pci_latency) {
814 CX18_INFO("Unreasonably low latency timer, "
815 "setting to 64 (was %d)\n", pci_latency);
816 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
817 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
820 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
821 "irq: %d, latency: %d, memory: 0x%lx\n",
822 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
823 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
824 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
829 static void cx18_init_subdevs(struct cx18 *cx)
831 u32 hw = cx->card->hw_all;
835 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
842 case CX18_HW_TVEEPROM:
843 /* These subordinate devices do not use probing */
844 cx->hw_flags |= device;
847 /* The A/V decoder gets probed earlier to set PLLs */
848 /* Just note that the card uses it (i.e. has analog) */
849 cx->hw_flags |= device;
851 case CX18_HW_GPIO_RESET_CTRL:
853 * The Reset Controller gets probed and added to
854 * hw_flags earlier for i2c adapter/bus initialization
857 case CX18_HW_GPIO_MUX:
858 if (cx18_gpio_register(cx, device) == 0)
859 cx->hw_flags |= device;
862 if (cx18_i2c_register(cx, i) == 0)
863 cx->hw_flags |= device;
868 if (cx->hw_flags & CX18_HW_418_AV)
869 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
871 if (cx->card->hw_muxer != 0)
872 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
875 static int __devinit cx18_probe(struct pci_dev *pci_dev,
876 const struct pci_device_id *pci_id)
883 /* FIXME - module parameter arrays constrain max instances */
884 i = atomic_inc_return(&cx18_instance) - 1;
885 if (i >= CX18_MAX_CARDS) {
886 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
887 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
891 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
893 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
897 cx->pci_dev = pci_dev;
900 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
902 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
907 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
909 CX18_INFO("Initializing card %d\n", cx->instance);
911 cx18_process_options(cx);
912 if (cx->options.cardtype == -1) {
917 retval = cx18_init_struct1(cx);
921 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
923 /* PCI Device Setup */
924 retval = cx18_setup_pci(cx, pci_dev, pci_id);
926 goto free_workqueues;
929 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
930 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
931 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
934 CX18_ERR("ioremap failed. Can't get a window into CX23418 "
935 "memory and register space\n");
936 CX18_ERR("Each capture card with a CX23418 needs 64 MB of "
937 "vmalloc address space for the window\n");
938 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
939 CX18_ERR("Use the vmalloc= kernel command line option to set "
940 "VmallocTotal to a larger value\n");
944 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
945 devtype = cx18_read_reg(cx, 0xC72028);
946 switch (devtype & 0xff000000) {
948 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
951 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
954 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
958 cx18_init_power(cx, 1);
959 cx18_init_memory(cx);
961 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
966 /* Initialize integrated A/V decoder early to set PLLs, just in case */
967 retval = cx18_av_probe(cx);
969 CX18_ERR("Could not register A/V decoder subdevice\n");
973 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
974 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
975 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
976 CX18_WARN("Could not register GPIO reset controller"
977 "subdevice; proceeding anyway.\n");
979 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
983 CX18_DEBUG_INFO("activating i2c...\n");
984 retval = init_cx18_i2c(cx);
986 CX18_ERR("Could not initialize i2c\n");
990 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
991 /* Based on the model number the cardtype may be changed.
992 The PCI IDs are not always reliable. */
993 cx18_process_eeprom(cx);
995 if (cx->card->comment)
996 CX18_INFO("%s", cx->card->comment);
997 if (cx->card->v4l2_capabilities == 0) {
1001 cx18_init_memory(cx);
1005 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
1006 IRQF_SHARED | IRQF_DISABLED,
1007 cx->v4l2_dev.name, (void *)cx);
1009 CX18_ERR("Failed to register irq %d\n", retval);
1014 cx->std = V4L2_STD_NTSC_M;
1016 if (cx->options.tuner == -1) {
1017 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
1018 if ((cx->std & cx->card->tuners[i].std) == 0)
1020 cx->options.tuner = cx->card->tuners[i].tuner;
1024 /* if no tuner was found, then pick the first tuner in the card list */
1025 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
1026 cx->std = cx->card->tuners[0].std;
1027 if (cx->std & V4L2_STD_PAL)
1028 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1029 else if (cx->std & V4L2_STD_NTSC)
1030 cx->std = V4L2_STD_NTSC_M;
1031 else if (cx->std & V4L2_STD_SECAM)
1032 cx->std = V4L2_STD_SECAM_L;
1033 cx->options.tuner = cx->card->tuners[0].tuner;
1035 if (cx->options.radio == -1)
1036 cx->options.radio = (cx->card->radio_input.audio_type != 0);
1038 /* The card is now fully identified, continue with card-specific
1040 cx18_init_struct2(cx);
1042 cx18_init_subdevs(cx);
1044 if (cx->std & V4L2_STD_525_60)
1049 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
1051 if (cx->options.radio > 0)
1052 cx->v4l2_cap |= V4L2_CAP_RADIO;
1054 if (cx->options.tuner > -1) {
1055 struct tuner_setup setup;
1057 setup.addr = ADDR_UNSET;
1058 setup.type = cx->options.tuner;
1059 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1060 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1061 cx18_reset_tuner_gpio : NULL;
1062 cx18_call_all(cx, tuner, s_type_addr, &setup);
1063 if (setup.type == TUNER_XC2028) {
1064 static struct xc2028_ctrl ctrl = {
1065 .fname = XC2028_DEFAULT_FIRMWARE,
1068 struct v4l2_priv_tun_config cfg = {
1069 .tuner = cx->options.tuner,
1072 cx18_call_all(cx, tuner, s_config, &cfg);
1076 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1078 cx->tuner_std = cx->std;
1080 retval = cx18_streams_setup(cx);
1082 CX18_ERR("Error %d setting up streams\n", retval);
1085 retval = cx18_streams_register(cx);
1087 CX18_ERR("Error %d registering devices\n", retval);
1091 CX18_INFO("Initialized card: %s\n", cx->card_name);
1093 /* Load cx18 submodules (cx18-alsa) */
1094 request_modules(cx);
1099 cx18_streams_cleanup(cx, 1);
1101 free_irq(cx->pci_dev->irq, (void *)cx);
1107 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1109 destroy_workqueue(cx->in_work_queue);
1110 destroy_workqueue(cx->out_work_queue);
1114 CX18_ERR("Error %d on initialization\n", retval);
1116 v4l2_device_unregister(&cx->v4l2_dev);
1121 int cx18_init_on_first_open(struct cx18 *cx)
1124 int fw_retry_count = 3;
1125 struct v4l2_frequency vf;
1126 struct cx18_open_id fh;
1130 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1133 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1136 while (--fw_retry_count > 0) {
1138 if (cx18_firmware_init(cx) == 0)
1140 if (fw_retry_count > 1)
1141 CX18_WARN("Retry loading firmware\n");
1144 if (fw_retry_count == 0) {
1145 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1148 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1151 * Init the firmware twice to work around a silicon bug
1152 * with the digital TS.
1154 * The second firmware load requires us to normalize the APU state,
1155 * or the audio for the first analog capture will be badly incorrect.
1157 * I can't seem to call APU_RESETAI and have it succeed without the
1158 * APU capturing audio, so we start and stop it here to do the reset
1161 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1162 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1163 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1164 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1167 while (--fw_retry_count > 0) {
1169 if (cx18_firmware_init(cx) == 0)
1171 if (fw_retry_count > 1)
1172 CX18_WARN("Retry loading firmware\n");
1175 if (fw_retry_count == 0) {
1176 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1181 * The second firmware load requires us to normalize the APU state,
1182 * or the audio for the first analog capture will be badly incorrect.
1184 * I can't seem to call APU_RESETAI and have it succeed without the
1185 * APU capturing audio, so we start and stop it here to do the reset
1188 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1189 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1190 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1191 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1193 /* Init the A/V decoder, if it hasn't been already */
1194 v4l2_subdev_call(cx->sd_av, core, load_fw);
1197 vf.type = V4L2_TUNER_ANALOG_TV;
1198 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1200 /* Set initial frequency. For PAL/SECAM broadcasts no
1201 'default' channel exists AFAIK. */
1202 if (cx->std == V4L2_STD_NTSC_M_JP)
1203 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1204 else if (cx->std & V4L2_STD_NTSC_M)
1205 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1207 video_input = cx->active_input;
1208 cx->active_input++; /* Force update of input */
1209 cx18_s_input(NULL, &fh, video_input);
1211 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1213 cx->std++; /* Force full standard initialization */
1214 cx18_s_std(NULL, &fh, &cx->tuner_std);
1215 cx18_s_frequency(NULL, &fh, &vf);
1219 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1222 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1223 cancel_work_sync(&cx->in_work_order[i].work);
1226 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1229 for (i = 0; i < CX18_MAX_STREAMS; i++)
1230 if (&cx->streams[i].video_dev != NULL)
1231 cancel_work_sync(&cx->streams[i].out_work_order);
1234 static void cx18_remove(struct pci_dev *pci_dev)
1236 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1237 struct cx18 *cx = to_cx18(v4l2_dev);
1240 CX18_DEBUG_INFO("Removing Card\n");
1242 flush_request_modules(cx);
1244 /* Stop all captures */
1245 CX18_DEBUG_INFO("Stopping all streams\n");
1246 if (atomic_read(&cx->tot_capturing) > 0)
1247 cx18_stop_all_captures(cx);
1249 /* Stop interrupts that cause incoming work to be queued */
1250 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1252 /* Incoming work can cause outgoing work, so clean up incoming first */
1253 cx18_cancel_in_work_orders(cx);
1254 cx18_cancel_out_work_orders(cx);
1256 /* Stop ack interrupts that may have been needed for work to finish */
1257 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1259 cx18_halt_firmware(cx);
1261 destroy_workqueue(cx->in_work_queue);
1262 destroy_workqueue(cx->out_work_queue);
1264 cx18_streams_cleanup(cx, 1);
1268 free_irq(cx->pci_dev->irq, (void *)cx);
1272 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1274 pci_disable_device(cx->pci_dev);
1276 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1277 for (i = 0; i < CX18_VBI_FRAMES; i++)
1278 kfree(cx->vbi.sliced_mpeg_data[i]);
1280 CX18_INFO("Removed %s\n", cx->card_name);
1282 v4l2_device_unregister(v4l2_dev);
1287 /* define a pci_driver for card detection */
1288 static struct pci_driver cx18_pci_driver = {
1290 .id_table = cx18_pci_tbl,
1291 .probe = cx18_probe,
1292 .remove = cx18_remove,
1295 static int __init module_start(void)
1297 printk(KERN_INFO "cx18: Start initialization, version %s\n",
1300 /* Validate parameters */
1301 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1302 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1303 CX18_MAX_CARDS - 1);
1307 if (cx18_debug < 0 || cx18_debug > 511) {
1309 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1312 if (pci_register_driver(&cx18_pci_driver)) {
1313 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1316 printk(KERN_INFO "cx18: End initialization\n");
1320 static void __exit module_cleanup(void)
1322 pci_unregister_driver(&cx18_pci_driver);
1325 module_init(module_start);
1326 module_exit(module_cleanup);