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 10 = Hauppauge HVR 1600 (S5H1411)\n"
161 "\t\t\t 0 = Autodetect (default)\n"
162 "\t\t\t-1 = Ignore this card\n\t\t");
163 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
164 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
165 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
166 MODULE_PARM_DESC(debug,
167 "Debug level (bitmask). Default: 0\n"
168 "\t\t\t 1/0x0001: warning\n"
169 "\t\t\t 2/0x0002: info\n"
170 "\t\t\t 4/0x0004: mailbox\n"
171 "\t\t\t 8/0x0008: dma\n"
172 "\t\t\t 16/0x0010: ioctl\n"
173 "\t\t\t 32/0x0020: file\n"
174 "\t\t\t 64/0x0040: i2c\n"
175 "\t\t\t128/0x0080: irq\n"
176 "\t\t\t256/0x0100: high volume\n");
177 MODULE_PARM_DESC(cx18_pci_latency,
178 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
179 "\t\t\tDefault: Yes");
180 MODULE_PARM_DESC(retry_mmio,
181 "(Deprecated) MMIO writes are now always checked and retried\n"
182 "\t\t\tEffectively: 1 [Yes]");
183 MODULE_PARM_DESC(mmio_ndelay,
184 "(Deprecated) MMIO accesses are now never purposely delayed\n"
185 "\t\t\tEffectively: 0 ns");
186 MODULE_PARM_DESC(enc_ts_buffers,
187 "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
188 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
189 MODULE_PARM_DESC(enc_ts_bufsize,
190 "Size of an encoder TS buffer (kB)\n"
191 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
192 MODULE_PARM_DESC(enc_ts_bufs,
193 "Number of encoder TS buffers\n"
194 "\t\t\tDefault is computed from other enc_ts_* parameters");
195 MODULE_PARM_DESC(enc_mpg_buffers,
196 "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
197 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
198 MODULE_PARM_DESC(enc_mpg_bufsize,
199 "Size of an encoder MPG buffer (kB)\n"
200 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
201 MODULE_PARM_DESC(enc_mpg_bufs,
202 "Number of encoder MPG buffers\n"
203 "\t\t\tDefault is computed from other enc_mpg_* parameters");
204 MODULE_PARM_DESC(enc_idx_buffers,
205 "(Deprecated) Encoder IDX buffer memory (MB)\n"
206 "\t\t\tIgnored, except 0 disables IDX buffer allocations\n"
207 "\t\t\tDefault: 1 [Enabled]");
208 MODULE_PARM_DESC(enc_idx_bufsize,
209 "Size of an encoder IDX buffer (kB)\n"
210 "\t\t\tAllowed values are multiples of 1.5 kB rounded up\n"
211 "\t\t\t(multiples of size required for 64 index entries)\n"
213 MODULE_PARM_DESC(enc_idx_bufs,
214 "Number of encoder IDX buffers\n"
215 "\t\t\tDefault: " __stringify(CX18_MAX_FW_MDLS_PER_STREAM));
216 MODULE_PARM_DESC(enc_yuv_buffers,
217 "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
218 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
219 MODULE_PARM_DESC(enc_yuv_bufsize,
220 "Size of an encoder YUV buffer (kB)\n"
221 "\t\t\tAllowed values are multiples of 33.75 kB rounded up\n"
222 "\t\t\t(multiples of size required for 32 screen lines)\n"
223 "\t\t\tDefault: 102");
224 MODULE_PARM_DESC(enc_yuv_bufs,
225 "Number of encoder YUV buffers\n"
226 "\t\t\tDefault is computed from other enc_yuv_* parameters");
227 MODULE_PARM_DESC(enc_vbi_buffers,
228 "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
229 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
230 MODULE_PARM_DESC(enc_vbi_bufs,
231 "Number of encoder VBI buffers\n"
232 "\t\t\tDefault is computed from enc_vbi_buffers");
233 MODULE_PARM_DESC(enc_pcm_buffers,
234 "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
235 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
236 MODULE_PARM_DESC(enc_pcm_bufsize,
237 "Size of an encoder PCM buffer (kB)\n"
238 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
239 MODULE_PARM_DESC(enc_pcm_bufs,
240 "Number of encoder PCM buffers\n"
241 "\t\t\tDefault is computed from other enc_pcm_* parameters");
243 MODULE_PARM_DESC(cx18_first_minor,
244 "Set device node number assigned to first card");
246 MODULE_AUTHOR("Hans Verkuil");
247 MODULE_DESCRIPTION("CX23418 driver");
248 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
249 MODULE_LICENSE("GPL");
251 MODULE_VERSION(CX18_VERSION);
253 #if defined(CONFIG_MODULES) && defined(MODULE)
254 static void request_module_async(struct work_struct *work)
256 struct cx18 *dev = container_of(work, struct cx18, request_module_wk);
258 /* Make sure cx18-alsa module is loaded */
259 request_module("cx18-alsa");
261 /* Initialize cx18-alsa for this instance of the cx18 device */
262 if (cx18_ext_init != NULL)
266 static void request_modules(struct cx18 *dev)
268 INIT_WORK(&dev->request_module_wk, request_module_async);
269 schedule_work(&dev->request_module_wk);
272 static void flush_request_modules(struct cx18 *dev)
274 flush_work_sync(&dev->request_module_wk);
277 #define request_modules(dev)
278 #define flush_request_modules(dev)
279 #endif /* CONFIG_MODULES */
281 /* Generic utility functions */
282 int cx18_msleep_timeout(unsigned int msecs, int intr)
284 long int timeout = msecs_to_jiffies(msecs);
288 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
289 timeout = schedule_timeout(timeout);
290 sig = intr ? signal_pending(current) : 0;
291 } while (!sig && timeout);
295 /* Release ioremapped memory */
296 static void cx18_iounmap(struct cx18 *cx)
301 /* Release io memory */
302 if (cx->enc_mem != NULL) {
303 CX18_DEBUG_INFO("releasing enc_mem\n");
304 iounmap(cx->enc_mem);
309 static void cx18_eeprom_dump(struct cx18 *cx, unsigned char *eedata, int len)
313 CX18_INFO("eeprom dump:\n");
314 for (i = 0; i < len; i++) {
316 CX18_INFO("eeprom %02x:", i);
317 printk(KERN_CONT " %02x", eedata[i]);
319 printk(KERN_CONT "\n");
323 /* Hauppauge card? get values from tveeprom */
324 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
329 memset(&c, 0, sizeof(c));
330 strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
331 c.adapter = &cx->i2c_adap[0];
334 memset(tv, 0, sizeof(*tv));
335 if (tveeprom_read(&c, eedata, sizeof(eedata)))
338 switch (cx->card->type) {
339 case CX18_CARD_HVR_1600_ESMT:
340 case CX18_CARD_HVR_1600_SAMSUNG:
341 case CX18_CARD_HVR_1600_S5H1411:
342 tveeprom_hauppauge_analog(&c, tv, eedata);
344 case CX18_CARD_YUAN_MPC718:
345 case CX18_CARD_GOTVIEW_PCI_DVD3:
347 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
348 CX18_INFO("eeprom PCI ID: %02x%02x:%02x%02x\n",
349 eedata[2], eedata[1], eedata[4], eedata[3]);
352 tv->model = 0xffffffff;
353 cx18_eeprom_dump(cx, eedata, sizeof(eedata));
358 static void cx18_process_eeprom(struct cx18 *cx)
362 cx18_read_eeprom(cx, &tv);
364 /* Many thanks to Steven Toth from Hauppauge for providing the
366 /* Note: the Samsung memory models cannot be reliably determined
367 from the model number. Use the cardtype module option if you
368 have one of these preproduction models. */
370 case 74301: /* Retail models */
372 case 74351: /* OEM models */
374 /* Digital side is s5h1411/tda18271 */
375 cx->card = cx18_get_card(CX18_CARD_HVR_1600_S5H1411);
377 case 74021: /* Retail models */
381 case 74541: /* OEM models */
388 /* Digital side is s5h1409/mxl5005s */
389 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
394 CX18_INFO("Unknown EEPROM encoding\n");
397 CX18_ERR("Invalid EEPROM\n");
400 CX18_ERR("Unknown model %d, defaulting to original HVR-1600 "
401 "(cardtype=1)\n", tv.model);
402 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
406 cx->v4l2_cap = cx->card->v4l2_capabilities;
407 cx->card_name = cx->card->name;
408 cx->card_i2c = cx->card->i2c;
410 CX18_INFO("Autodetected %s\n", cx->card_name);
412 if (tv.tuner_type == TUNER_ABSENT)
413 CX18_ERR("tveeprom cannot autodetect tuner!\n");
415 if (cx->options.tuner == -1)
416 cx->options.tuner = tv.tuner_type;
417 if (cx->options.radio == -1)
418 cx->options.radio = (tv.has_radio != 0);
421 /* user specified tuner standard */
424 /* autodetect tuner standard */
425 if (tv.tuner_formats & V4L2_STD_PAL) {
426 CX18_DEBUG_INFO("PAL tuner detected\n");
427 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
428 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
429 CX18_DEBUG_INFO("NTSC tuner detected\n");
430 cx->std |= V4L2_STD_NTSC_M;
431 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
432 CX18_DEBUG_INFO("SECAM tuner detected\n");
433 cx->std |= V4L2_STD_SECAM_L;
435 CX18_INFO("No tuner detected, default to NTSC-M\n");
436 cx->std |= V4L2_STD_NTSC_M;
440 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
444 return V4L2_STD_PAL_60;
449 return V4L2_STD_PAL_BG;
452 return V4L2_STD_PAL_H;
455 if (pal[1] == 'c' || pal[1] == 'C')
456 return V4L2_STD_PAL_Nc;
457 return V4L2_STD_PAL_N;
460 return V4L2_STD_PAL_I;
465 return V4L2_STD_PAL_DK;
468 return V4L2_STD_PAL_M;
472 CX18_WARN("pal= argument not recognised\n");
483 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
488 return V4L2_STD_SECAM_DK;
491 if (secam[1] == 'C' || secam[1] == 'c')
492 return V4L2_STD_SECAM_LC;
493 return V4L2_STD_SECAM_L;
497 CX18_WARN("secam= argument not recognised\n");
504 return V4L2_STD_NTSC_M;
507 return V4L2_STD_NTSC_M_JP;
510 return V4L2_STD_NTSC_M_KR;
514 CX18_WARN("ntsc= argument not recognised\n");
522 static void cx18_process_options(struct cx18 *cx)
526 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
527 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
528 cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
529 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
530 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
531 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
532 cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
534 cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
535 cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
536 cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
537 cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
538 cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
539 cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
540 cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
542 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
543 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
544 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
545 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
546 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
547 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
548 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
550 /* Ensure stream_buffers & stream_buf_size are valid */
551 for (i = 0; i < CX18_MAX_STREAMS; i++) {
552 if (cx->stream_buffers[i] == 0 || /* User said 0 buffers */
553 cx->options.megabytes[i] <= 0 || /* User said 0 MB total */
554 cx->stream_buf_size[i] <= 0) { /* User said buf size 0 */
555 cx->options.megabytes[i] = 0;
556 cx->stream_buffers[i] = 0;
557 cx->stream_buf_size[i] = 0;
561 * YUV is a special case where the stream_buf_size needs to be
562 * an integral multiple of 33.75 kB (storage for 32 screens
563 * lines to maintain alignment in case of lost buffers).
565 * IDX is a special case where the stream_buf_size should be
566 * an integral multiple of 1.5 kB (storage for 64 index entries
567 * to maintain alignment in case of lost buffers).
570 if (i == CX18_ENC_STREAM_TYPE_YUV) {
571 cx->stream_buf_size[i] *= 1024;
572 cx->stream_buf_size[i] -=
573 (cx->stream_buf_size[i] % CX18_UNIT_ENC_YUV_BUFSIZE);
575 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_YUV_BUFSIZE)
576 cx->stream_buf_size[i] =
577 CX18_UNIT_ENC_YUV_BUFSIZE;
578 } else if (i == CX18_ENC_STREAM_TYPE_IDX) {
579 cx->stream_buf_size[i] *= 1024;
580 cx->stream_buf_size[i] -=
581 (cx->stream_buf_size[i] % CX18_UNIT_ENC_IDX_BUFSIZE);
583 if (cx->stream_buf_size[i] < CX18_UNIT_ENC_IDX_BUFSIZE)
584 cx->stream_buf_size[i] =
585 CX18_UNIT_ENC_IDX_BUFSIZE;
588 * YUV and IDX are special cases where the stream_buf_size is
590 * VBI is a special case where the stream_buf_size is fixed
591 * and already in bytes
593 if (i == CX18_ENC_STREAM_TYPE_VBI ||
594 i == CX18_ENC_STREAM_TYPE_YUV ||
595 i == CX18_ENC_STREAM_TYPE_IDX) {
596 if (cx->stream_buffers[i] < 0) {
597 cx->stream_buffers[i] =
598 cx->options.megabytes[i] * 1024 * 1024
599 / cx->stream_buf_size[i];
601 /* N.B. This might round down to 0 */
602 cx->options.megabytes[i] =
603 cx->stream_buffers[i]
604 * cx->stream_buf_size[i]/(1024 * 1024);
607 /* All other streams have stream_buf_size in kB here */
608 if (cx->stream_buffers[i] < 0) {
609 cx->stream_buffers[i] =
610 cx->options.megabytes[i] * 1024
611 / cx->stream_buf_size[i];
613 /* N.B. This might round down to 0 */
614 cx->options.megabytes[i] =
615 cx->stream_buffers[i]
616 * cx->stream_buf_size[i] / 1024;
618 /* convert from kB to bytes */
619 cx->stream_buf_size[i] *= 1024;
621 CX18_DEBUG_INFO("Stream type %d options: %d MB, %d buffers, "
622 "%d bytes\n", i, cx->options.megabytes[i],
623 cx->stream_buffers[i], cx->stream_buf_size[i]);
626 cx->options.cardtype = cardtype[cx->instance];
627 cx->options.tuner = tuner[cx->instance];
628 cx->options.radio = radio[cx->instance];
630 cx->std = cx18_parse_std(cx);
631 if (cx->options.cardtype == -1) {
632 CX18_INFO("Ignore card\n");
635 cx->card = cx18_get_card(cx->options.cardtype - 1);
637 CX18_INFO("User specified %s card\n", cx->card->name);
638 else if (cx->options.cardtype != 0)
639 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
640 if (cx->card == NULL) {
641 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
642 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
643 CX18_INFO("Autodetected Hauppauge card\n");
646 if (cx->card == NULL) {
647 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
648 if (cx->card->pci_list == NULL)
650 for (j = 0; cx->card->pci_list[j].device; j++) {
651 if (cx->pci_dev->device !=
652 cx->card->pci_list[j].device)
654 if (cx->pci_dev->subsystem_vendor !=
655 cx->card->pci_list[j].subsystem_vendor)
657 if (cx->pci_dev->subsystem_device !=
658 cx->card->pci_list[j].subsystem_device)
660 CX18_INFO("Autodetected %s card\n", cx->card->name);
667 if (cx->card == NULL) {
668 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
669 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
670 cx->pci_dev->vendor, cx->pci_dev->device);
671 CX18_ERR(" subsystem vendor/device: [%04x:%04x]\n",
672 cx->pci_dev->subsystem_vendor,
673 cx->pci_dev->subsystem_device);
674 CX18_ERR("Defaulting to %s card\n", cx->card->name);
675 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
676 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
677 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
679 cx->v4l2_cap = cx->card->v4l2_capabilities;
680 cx->card_name = cx->card->name;
681 cx->card_i2c = cx->card->i2c;
684 static int __devinit cx18_create_in_workq(struct cx18 *cx)
686 snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
688 cx->in_work_queue = alloc_ordered_workqueue(cx->in_workq_name, 0);
689 if (cx->in_work_queue == NULL) {
690 CX18_ERR("Unable to create incoming mailbox handler thread\n");
696 static void __devinit cx18_init_in_work_orders(struct cx18 *cx)
699 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
700 cx->in_work_order[i].cx = cx;
701 cx->in_work_order[i].str = cx->epu_debug_str;
702 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
706 /* Precondition: the cx18 structure has been memset to 0. Only
707 the dev and instance fields have been filled in.
708 No assumptions on the card type may be made here (see cx18_init_struct2
711 static int __devinit cx18_init_struct1(struct cx18 *cx)
715 cx->base_addr = pci_resource_start(cx->pci_dev, 0);
717 mutex_init(&cx->serialize_lock);
718 mutex_init(&cx->gpio_lock);
719 mutex_init(&cx->epu2apu_mb_lock);
720 mutex_init(&cx->epu2cpu_mb_lock);
722 ret = cx18_create_in_workq(cx);
726 cx18_init_in_work_orders(cx);
728 /* start counting open_id at 1 */
731 /* Initial settings */
732 cx2341x_fill_defaults(&cx->params);
733 cx->temporal_strength = cx->params.video_temporal_filter;
734 cx->spatial_strength = cx->params.video_spatial_filter;
735 cx->filter_mode = cx->params.video_spatial_filter_mode |
736 (cx->params.video_temporal_filter_mode << 1) |
737 (cx->params.video_median_filter_type << 2);
738 cx->params.port = CX2341X_PORT_MEMORY;
739 cx->params.capabilities =
740 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
741 init_waitqueue_head(&cx->cap_w);
742 init_waitqueue_head(&cx->mb_apu_waitq);
743 init_waitqueue_head(&cx->mb_cpu_waitq);
744 init_waitqueue_head(&cx->dma_waitq);
747 cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
748 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
750 /* IVTV style VBI insertion into MPEG streams */
751 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_buf.list);
752 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.list);
753 INIT_LIST_HEAD(&cx->vbi.sliced_mpeg_mdl.buf_list);
754 list_add(&cx->vbi.sliced_mpeg_buf.list,
755 &cx->vbi.sliced_mpeg_mdl.buf_list);
759 /* Second initialization part. Here the card type has been
761 static void __devinit cx18_init_struct2(struct cx18 *cx)
765 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
766 if (cx->card->video_inputs[i].video_type == 0)
769 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
770 if (cx->card->audio_inputs[i].audio_type == 0)
772 cx->nof_audio_inputs = i;
774 /* Find tuner input */
775 for (i = 0; i < cx->nof_inputs; i++) {
776 if (cx->card->video_inputs[i].video_type ==
777 CX18_CARD_INPUT_VID_TUNER)
780 if (i == cx->nof_inputs)
782 cx->active_input = i;
783 cx->audio_input = cx->card->video_inputs[i].audio_index;
786 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
787 const struct pci_device_id *pci_id)
790 unsigned char pci_latency;
792 CX18_DEBUG_INFO("Enabling pci device\n");
794 if (pci_enable_device(pci_dev)) {
795 CX18_ERR("Can't enable device %d!\n", cx->instance);
798 if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
799 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
802 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
803 CX18_ERR("Cannot request encoder memory region, card %d\n",
808 /* Enable bus mastering and memory mapped IO for the CX23418 */
809 pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
810 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
811 pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
813 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
814 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
816 if (pci_latency < 64 && cx18_pci_latency) {
817 CX18_INFO("Unreasonably low latency timer, "
818 "setting to 64 (was %d)\n", pci_latency);
819 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
820 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
823 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
824 "irq: %d, latency: %d, memory: 0x%lx\n",
825 cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
826 PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
827 cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
832 static void cx18_init_subdevs(struct cx18 *cx)
834 u32 hw = cx->card->hw_all;
838 for (i = 0, device = 1; i < 32; i++, device <<= 1) {
845 case CX18_HW_TVEEPROM:
846 /* These subordinate devices do not use probing */
847 cx->hw_flags |= device;
850 /* The A/V decoder gets probed earlier to set PLLs */
851 /* Just note that the card uses it (i.e. has analog) */
852 cx->hw_flags |= device;
854 case CX18_HW_GPIO_RESET_CTRL:
856 * The Reset Controller gets probed and added to
857 * hw_flags earlier for i2c adapter/bus initialization
860 case CX18_HW_GPIO_MUX:
861 if (cx18_gpio_register(cx, device) == 0)
862 cx->hw_flags |= device;
865 if (cx18_i2c_register(cx, i) == 0)
866 cx->hw_flags |= device;
871 if (cx->hw_flags & CX18_HW_418_AV)
872 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
874 if (cx->card->hw_muxer != 0)
875 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
878 static int __devinit cx18_probe(struct pci_dev *pci_dev,
879 const struct pci_device_id *pci_id)
886 /* FIXME - module parameter arrays constrain max instances */
887 i = atomic_inc_return(&cx18_instance) - 1;
888 if (i >= CX18_MAX_CARDS) {
889 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
890 "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
894 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
896 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
900 cx->pci_dev = pci_dev;
903 retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
905 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
910 snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
912 CX18_INFO("Initializing card %d\n", cx->instance);
914 cx18_process_options(cx);
915 if (cx->options.cardtype == -1) {
920 retval = cx18_init_struct1(cx);
924 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
926 /* PCI Device Setup */
927 retval = cx18_setup_pci(cx, pci_dev, pci_id);
929 goto free_workqueues;
932 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
933 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
934 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
937 CX18_ERR("ioremap failed. Can't get a window into CX23418 "
938 "memory and register space\n");
939 CX18_ERR("Each capture card with a CX23418 needs 64 MB of "
940 "vmalloc address space for the window\n");
941 CX18_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
942 CX18_ERR("Use the vmalloc= kernel command line option to set "
943 "VmallocTotal to a larger value\n");
947 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
948 devtype = cx18_read_reg(cx, 0xC72028);
949 switch (devtype & 0xff000000) {
951 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
954 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
957 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
961 cx18_init_power(cx, 1);
962 cx18_init_memory(cx);
964 cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
969 /* Initialize integrated A/V decoder early to set PLLs, just in case */
970 retval = cx18_av_probe(cx);
972 CX18_ERR("Could not register A/V decoder subdevice\n");
976 /* Initialize GPIO Reset Controller to do chip resets during i2c init */
977 if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
978 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
979 CX18_WARN("Could not register GPIO reset controller"
980 "subdevice; proceeding anyway.\n");
982 cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
986 CX18_DEBUG_INFO("activating i2c...\n");
987 retval = init_cx18_i2c(cx);
989 CX18_ERR("Could not initialize i2c\n");
993 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
994 /* Based on the model number the cardtype may be changed.
995 The PCI IDs are not always reliable. */
996 cx18_process_eeprom(cx);
998 if (cx->card->comment)
999 CX18_INFO("%s", cx->card->comment);
1000 if (cx->card->v4l2_capabilities == 0) {
1004 cx18_init_memory(cx);
1008 retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
1009 IRQF_SHARED | IRQF_DISABLED,
1010 cx->v4l2_dev.name, (void *)cx);
1012 CX18_ERR("Failed to register irq %d\n", retval);
1017 cx->std = V4L2_STD_NTSC_M;
1019 if (cx->options.tuner == -1) {
1020 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
1021 if ((cx->std & cx->card->tuners[i].std) == 0)
1023 cx->options.tuner = cx->card->tuners[i].tuner;
1027 /* if no tuner was found, then pick the first tuner in the card list */
1028 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
1029 cx->std = cx->card->tuners[0].std;
1030 if (cx->std & V4L2_STD_PAL)
1031 cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1032 else if (cx->std & V4L2_STD_NTSC)
1033 cx->std = V4L2_STD_NTSC_M;
1034 else if (cx->std & V4L2_STD_SECAM)
1035 cx->std = V4L2_STD_SECAM_L;
1036 cx->options.tuner = cx->card->tuners[0].tuner;
1038 if (cx->options.radio == -1)
1039 cx->options.radio = (cx->card->radio_input.audio_type != 0);
1041 /* The card is now fully identified, continue with card-specific
1043 cx18_init_struct2(cx);
1045 cx18_init_subdevs(cx);
1047 if (cx->std & V4L2_STD_525_60)
1052 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
1054 if (cx->options.radio > 0)
1055 cx->v4l2_cap |= V4L2_CAP_RADIO;
1057 if (cx->options.tuner > -1) {
1058 struct tuner_setup setup;
1060 setup.addr = ADDR_UNSET;
1061 setup.type = cx->options.tuner;
1062 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
1063 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1064 cx18_reset_tuner_gpio : NULL;
1065 cx18_call_all(cx, tuner, s_type_addr, &setup);
1066 if (setup.type == TUNER_XC2028) {
1067 static struct xc2028_ctrl ctrl = {
1068 .fname = XC2028_DEFAULT_FIRMWARE,
1071 struct v4l2_priv_tun_config cfg = {
1072 .tuner = cx->options.tuner,
1075 cx18_call_all(cx, tuner, s_config, &cfg);
1079 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1081 cx->tuner_std = cx->std;
1083 retval = cx18_streams_setup(cx);
1085 CX18_ERR("Error %d setting up streams\n", retval);
1088 retval = cx18_streams_register(cx);
1090 CX18_ERR("Error %d registering devices\n", retval);
1094 CX18_INFO("Initialized card: %s\n", cx->card_name);
1096 /* Load cx18 submodules (cx18-alsa) */
1097 request_modules(cx);
1102 cx18_streams_cleanup(cx, 1);
1104 free_irq(cx->pci_dev->irq, (void *)cx);
1110 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1112 destroy_workqueue(cx->in_work_queue);
1116 CX18_ERR("Error %d on initialization\n", retval);
1118 v4l2_device_unregister(&cx->v4l2_dev);
1123 int cx18_init_on_first_open(struct cx18 *cx)
1126 int fw_retry_count = 3;
1127 struct v4l2_frequency vf;
1128 struct cx18_open_id fh;
1132 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
1135 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
1138 while (--fw_retry_count > 0) {
1140 if (cx18_firmware_init(cx) == 0)
1142 if (fw_retry_count > 1)
1143 CX18_WARN("Retry loading firmware\n");
1146 if (fw_retry_count == 0) {
1147 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1150 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
1153 * Init the firmware twice to work around a silicon bug
1154 * with the digital TS.
1156 * The second firmware load requires us to normalize the APU state,
1157 * or the audio for the first analog capture will be badly incorrect.
1159 * I can't seem to call APU_RESETAI and have it succeed without the
1160 * APU capturing audio, so we start and stop it here to do the reset
1163 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1164 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1165 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1166 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1169 while (--fw_retry_count > 0) {
1171 if (cx18_firmware_init(cx) == 0)
1173 if (fw_retry_count > 1)
1174 CX18_WARN("Retry loading firmware\n");
1177 if (fw_retry_count == 0) {
1178 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1183 * The second firmware load requires us to normalize the APU state,
1184 * or the audio for the first analog capture will be badly incorrect.
1186 * I can't seem to call APU_RESETAI and have it succeed without the
1187 * APU capturing audio, so we start and stop it here to do the reset
1190 /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1191 cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1192 cx18_vapi(cx, CX18_APU_RESETAI, 0);
1193 cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1195 /* Init the A/V decoder, if it hasn't been already */
1196 v4l2_subdev_call(cx->sd_av, core, load_fw);
1199 vf.type = V4L2_TUNER_ANALOG_TV;
1200 vf.frequency = 6400; /* the tuner 'baseline' frequency */
1202 /* Set initial frequency. For PAL/SECAM broadcasts no
1203 'default' channel exists AFAIK. */
1204 if (cx->std == V4L2_STD_NTSC_M_JP)
1205 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
1206 else if (cx->std & V4L2_STD_NTSC_M)
1207 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
1209 video_input = cx->active_input;
1210 cx->active_input++; /* Force update of input */
1211 cx18_s_input(NULL, &fh, video_input);
1213 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1215 cx->std++; /* Force full standard initialization */
1216 cx18_s_std(NULL, &fh, &cx->tuner_std);
1217 cx18_s_frequency(NULL, &fh, &vf);
1221 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1224 for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1225 cancel_work_sync(&cx->in_work_order[i].work);
1228 static void cx18_cancel_out_work_orders(struct cx18 *cx)
1231 for (i = 0; i < CX18_MAX_STREAMS; i++)
1232 if (&cx->streams[i].video_dev != NULL)
1233 cancel_work_sync(&cx->streams[i].out_work_order);
1236 static void cx18_remove(struct pci_dev *pci_dev)
1238 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1239 struct cx18 *cx = to_cx18(v4l2_dev);
1242 CX18_DEBUG_INFO("Removing Card\n");
1244 flush_request_modules(cx);
1246 /* Stop all captures */
1247 CX18_DEBUG_INFO("Stopping all streams\n");
1248 if (atomic_read(&cx->tot_capturing) > 0)
1249 cx18_stop_all_captures(cx);
1251 /* Stop interrupts that cause incoming work to be queued */
1252 cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1254 /* Incoming work can cause outgoing work, so clean up incoming first */
1255 cx18_cancel_in_work_orders(cx);
1256 cx18_cancel_out_work_orders(cx);
1258 /* Stop ack interrupts that may have been needed for work to finish */
1259 cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1261 cx18_halt_firmware(cx);
1263 destroy_workqueue(cx->in_work_queue);
1265 cx18_streams_cleanup(cx, 1);
1269 free_irq(cx->pci_dev->irq, (void *)cx);
1273 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1275 pci_disable_device(cx->pci_dev);
1277 if (cx->vbi.sliced_mpeg_data[0] != NULL)
1278 for (i = 0; i < CX18_VBI_FRAMES; i++)
1279 kfree(cx->vbi.sliced_mpeg_data[i]);
1281 CX18_INFO("Removed %s\n", cx->card_name);
1283 v4l2_device_unregister(v4l2_dev);
1288 /* define a pci_driver for card detection */
1289 static struct pci_driver cx18_pci_driver = {
1291 .id_table = cx18_pci_tbl,
1292 .probe = cx18_probe,
1293 .remove = cx18_remove,
1296 static int __init module_start(void)
1298 printk(KERN_INFO "cx18: Start initialization, version %s\n",
1301 /* Validate parameters */
1302 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1303 printk(KERN_ERR "cx18: Exiting, cx18_first_minor must be between 0 and %d\n",
1304 CX18_MAX_CARDS - 1);
1308 if (cx18_debug < 0 || cx18_debug > 511) {
1310 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
1313 if (pci_register_driver(&cx18_pci_driver)) {
1314 printk(KERN_ERR "cx18: Error detecting PCI card\n");
1317 printk(KERN_INFO "cx18: End initialization\n");
1321 static void __exit module_cleanup(void)
1323 pci_unregister_driver(&cx18_pci_driver);
1326 module_init(module_start);
1327 module_exit(module_cleanup);