2 * cx18 driver initialization and card probing
4 * Derived from ivtv-driver.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 #include "cx18-driver.h"
25 #include "cx18-version.h"
26 #include "cx18-cards.h"
29 #include "cx18-gpio.h"
30 #include "cx18-firmware.h"
31 #include "cx18-streams.h"
32 #include "cx18-av-core.h"
34 #include "cx18-mailbox.h"
35 #include "cx18-ioctl.h"
36 #include "tuner-xc2028.h"
38 #include <media/tveeprom.h>
41 /* var to keep track of the number of array elements in use */
42 int cx18_cards_active;
44 /* If you have already X v4l cards, then set this to X. This way
45 the device numbers stay matched. Example: you have a WinTV card
46 without radio and a Compro H900 with. Normally this would give a
47 video1 device together with a radio0 device for the Compro. By
48 setting this to 1 you ensure that radio0 is now also radio1. */
51 /* Master variable for all cx18 info */
52 struct cx18 *cx18_cards[CX18_MAX_CARDS];
54 /* Protects cx18_cards_active */
55 DEFINE_SPINLOCK(cx18_cards_lock);
57 /* add your revision and whatnot here */
58 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
59 {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
60 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
64 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
66 /* Parameter declarations */
67 static int cardtype[CX18_MAX_CARDS];
68 static int tuner[CX18_MAX_CARDS] = { -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 -1, -1, -1, -1, -1, -1, -1, -1 };
72 static int radio[CX18_MAX_CARDS] = { -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 -1, -1, -1, -1, -1, -1, -1, -1 };
77 static int cardtype_c = 1;
78 static int tuner_c = 1;
79 static int radio_c = 1;
80 static char pal[] = "--";
81 static char secam[] = "--";
82 static char ntsc[] = "-";
85 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
86 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
87 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
88 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
89 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
91 static int cx18_pci_latency = 1;
95 module_param_array(tuner, int, &tuner_c, 0644);
96 module_param_array(radio, bool, &radio_c, 0644);
97 module_param_array(cardtype, int, &cardtype_c, 0644);
98 module_param_string(pal, pal, sizeof(pal), 0644);
99 module_param_string(secam, secam, sizeof(secam), 0644);
100 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
101 module_param_named(debug, cx18_debug, int, 0644);
102 module_param(cx18_pci_latency, int, 0644);
103 module_param(cx18_first_minor, int, 0644);
105 module_param(enc_mpg_buffers, int, 0644);
106 module_param(enc_ts_buffers, int, 0644);
107 module_param(enc_yuv_buffers, int, 0644);
108 module_param(enc_vbi_buffers, int, 0644);
109 module_param(enc_pcm_buffers, int, 0644);
111 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
112 "\t\t\tsee tuner.h for values");
113 MODULE_PARM_DESC(radio,
114 "Enable or disable the radio. Use only if autodetection\n"
115 "\t\t\tfails. 0 = disable, 1 = enable");
116 MODULE_PARM_DESC(cardtype,
117 "Only use this option if your card is not detected properly.\n"
118 "\t\tSpecify card type:\n"
119 "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
120 "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
121 "\t\t\t 3 = Compro VideoMate H900\n"
122 "\t\t\t 4 = Yuan MPC718\n"
123 "\t\t\t 0 = Autodetect (default)\n"
124 "\t\t\t-1 = Ignore this card\n\t\t");
125 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
126 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
127 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
128 MODULE_PARM_DESC(debug,
129 "Debug level (bitmask). Default: 0\n"
130 "\t\t\t 1/0x0001: warning\n"
131 "\t\t\t 2/0x0002: info\n"
132 "\t\t\t 4/0x0004: mailbox\n"
133 "\t\t\t 8/0x0008: dma\n"
134 "\t\t\t 16/0x0010: ioctl\n"
135 "\t\t\t 32/0x0020: file\n"
136 "\t\t\t 64/0x0040: i2c\n"
137 "\t\t\t128/0x0080: irq\n"
138 "\t\t\t256/0x0100: high volume\n");
139 MODULE_PARM_DESC(cx18_pci_latency,
140 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
141 "\t\t\tDefault: Yes");
142 MODULE_PARM_DESC(enc_mpg_buffers,
143 "Encoder MPG Buffers (in MB)\n"
144 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
145 MODULE_PARM_DESC(enc_ts_buffers,
146 "Encoder TS Buffers (in MB)\n"
147 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
148 MODULE_PARM_DESC(enc_yuv_buffers,
149 "Encoder YUV Buffers (in MB)\n"
150 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
151 MODULE_PARM_DESC(enc_vbi_buffers,
152 "Encoder VBI Buffers (in MB)\n"
153 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
154 MODULE_PARM_DESC(enc_pcm_buffers,
155 "Encoder PCM buffers (in MB)\n"
156 "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
158 MODULE_PARM_DESC(cx18_first_minor, "Set minor assigned to first card");
160 MODULE_AUTHOR("Hans Verkuil");
161 MODULE_DESCRIPTION("CX23418 driver");
162 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
163 MODULE_LICENSE("GPL");
165 MODULE_VERSION(CX18_VERSION);
167 /* Generic utility functions */
168 int cx18_msleep_timeout(unsigned int msecs, int intr)
170 int timeout = msecs_to_jiffies(msecs);
174 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
175 timeout = schedule_timeout(timeout);
176 sig = intr ? signal_pending(current) : 0;
177 } while (!sig && timeout);
181 /* Release ioremapped memory */
182 static void cx18_iounmap(struct cx18 *cx)
187 /* Release io memory */
188 if (cx->enc_mem != NULL) {
189 CX18_DEBUG_INFO("releasing enc_mem\n");
190 iounmap(cx->enc_mem);
195 /* Hauppauge card? get values from tveeprom */
196 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
200 cx->i2c_client[0].addr = 0xA0 >> 1;
201 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
202 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
205 static void cx18_process_eeprom(struct cx18 *cx)
209 cx18_read_eeprom(cx, &tv);
211 /* Many thanks to Steven Toth from Hauppauge for providing the
213 /* Note: the Samsung memory models cannot be reliably determined
214 from the model number. Use the cardtype module option if you
215 have one of these preproduction models. */
217 case 74000 ... 74999:
218 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
221 CX18_ERR("Invalid EEPROM\n");
224 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
225 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
229 cx->v4l2_cap = cx->card->v4l2_capabilities;
230 cx->card_name = cx->card->name;
231 cx->card_i2c = cx->card->i2c;
233 CX18_INFO("Autodetected %s\n", cx->card_name);
235 if (tv.tuner_type == TUNER_ABSENT)
236 CX18_ERR("tveeprom cannot autodetect tuner!");
238 if (cx->options.tuner == -1)
239 cx->options.tuner = tv.tuner_type;
240 if (cx->options.radio == -1)
241 cx->options.radio = (tv.has_radio != 0);
244 /* user specified tuner standard */
247 /* autodetect tuner standard */
248 if (tv.tuner_formats & V4L2_STD_PAL) {
249 CX18_DEBUG_INFO("PAL tuner detected\n");
250 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
251 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
252 CX18_DEBUG_INFO("NTSC tuner detected\n");
253 cx->std |= V4L2_STD_NTSC_M;
254 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
255 CX18_DEBUG_INFO("SECAM tuner detected\n");
256 cx->std |= V4L2_STD_SECAM_L;
258 CX18_INFO("No tuner detected, default to NTSC-M\n");
259 cx->std |= V4L2_STD_NTSC_M;
263 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
267 return V4L2_STD_PAL_60;
272 return V4L2_STD_PAL_BG;
275 return V4L2_STD_PAL_H;
278 if (pal[1] == 'c' || pal[1] == 'C')
279 return V4L2_STD_PAL_Nc;
280 return V4L2_STD_PAL_N;
283 return V4L2_STD_PAL_I;
288 return V4L2_STD_PAL_DK;
291 return V4L2_STD_PAL_M;
295 CX18_WARN("pal= argument not recognised\n");
306 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
311 return V4L2_STD_SECAM_DK;
314 if (secam[1] == 'C' || secam[1] == 'c')
315 return V4L2_STD_SECAM_LC;
316 return V4L2_STD_SECAM_L;
320 CX18_WARN("secam= argument not recognised\n");
327 return V4L2_STD_NTSC_M;
330 return V4L2_STD_NTSC_M_JP;
333 return V4L2_STD_NTSC_M_KR;
337 CX18_WARN("ntsc= argument not recognised\n");
345 static void cx18_process_options(struct cx18 *cx)
349 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
350 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
351 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
352 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
353 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
354 cx->options.cardtype = cardtype[cx->num];
355 cx->options.tuner = tuner[cx->num];
356 cx->options.radio = radio[cx->num];
358 cx->std = cx18_parse_std(cx);
359 if (cx->options.cardtype == -1) {
360 CX18_INFO("Ignore card\n");
363 cx->card = cx18_get_card(cx->options.cardtype - 1);
365 CX18_INFO("User specified %s card\n", cx->card->name);
366 else if (cx->options.cardtype != 0)
367 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
368 if (cx->card == NULL) {
369 if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
370 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
371 CX18_INFO("Autodetected Hauppauge card\n");
374 if (cx->card == NULL) {
375 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
376 if (cx->card->pci_list == NULL)
378 for (j = 0; cx->card->pci_list[j].device; j++) {
379 if (cx->dev->device !=
380 cx->card->pci_list[j].device)
382 if (cx->dev->subsystem_vendor !=
383 cx->card->pci_list[j].subsystem_vendor)
385 if (cx->dev->subsystem_device !=
386 cx->card->pci_list[j].subsystem_device)
388 CX18_INFO("Autodetected %s card\n", cx->card->name);
395 if (cx->card == NULL) {
396 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
397 CX18_ERR("Unknown card: vendor/device: %04x/%04x\n",
398 cx->dev->vendor, cx->dev->device);
399 CX18_ERR(" subsystem vendor/device: %04x/%04x\n",
400 cx->dev->subsystem_vendor, cx->dev->subsystem_device);
401 CX18_ERR("Defaulting to %s card\n", cx->card->name);
402 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
403 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
404 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
406 cx->v4l2_cap = cx->card->v4l2_capabilities;
407 cx->card_name = cx->card->name;
408 cx->card_i2c = cx->card->i2c;
411 /* Precondition: the cx18 structure has been memset to 0. Only
412 the dev and num fields have been filled in.
413 No assumptions on the card type may be made here (see cx18_init_struct2
416 static int __devinit cx18_init_struct1(struct cx18 *cx)
418 cx->base_addr = pci_resource_start(cx->dev, 0);
420 mutex_init(&cx->serialize_lock);
421 mutex_init(&cx->i2c_bus_lock[0]);
422 mutex_init(&cx->i2c_bus_lock[1]);
424 spin_lock_init(&cx->lock);
425 spin_lock_init(&cx->dma_reg_lock);
427 /* start counting open_id at 1 */
430 /* Initial settings */
431 cx2341x_fill_defaults(&cx->params);
432 cx->temporal_strength = cx->params.video_temporal_filter;
433 cx->spatial_strength = cx->params.video_spatial_filter;
434 cx->filter_mode = cx->params.video_spatial_filter_mode |
435 (cx->params.video_temporal_filter_mode << 1) |
436 (cx->params.video_median_filter_type << 2);
437 cx->params.port = CX2341X_PORT_MEMORY;
438 cx->params.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
439 init_waitqueue_head(&cx->cap_w);
440 init_waitqueue_head(&cx->mb_apu_waitq);
441 init_waitqueue_head(&cx->mb_cpu_waitq);
442 init_waitqueue_head(&cx->mb_epu_waitq);
443 init_waitqueue_head(&cx->mb_hpu_waitq);
444 init_waitqueue_head(&cx->dma_waitq);
447 cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
448 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
449 cx->vbi.raw_size = 1456;
450 cx->vbi.raw_decoder_line_size = 1456;
451 cx->vbi.raw_decoder_sav_odd_field = 0x20;
452 cx->vbi.raw_decoder_sav_even_field = 0x60;
453 cx->vbi.sliced_decoder_line_size = 272;
454 cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
455 cx->vbi.sliced_decoder_sav_even_field = 0xF0;
459 /* Second initialization part. Here the card type has been
461 static void __devinit cx18_init_struct2(struct cx18 *cx)
465 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
466 if (cx->card->video_inputs[i].video_type == 0)
469 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
470 if (cx->card->audio_inputs[i].audio_type == 0)
472 cx->nof_audio_inputs = i;
474 /* Find tuner input */
475 for (i = 0; i < cx->nof_inputs; i++) {
476 if (cx->card->video_inputs[i].video_type ==
477 CX18_CARD_INPUT_VID_TUNER)
480 if (i == cx->nof_inputs)
482 cx->active_input = i;
483 cx->audio_input = cx->card->video_inputs[i].audio_index;
484 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
485 cx->av_state.aud_input = CX18_AV_AUDIO8;
486 cx->av_state.audclk_freq = 48000;
487 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
488 cx->av_state.vbi_line_offset = 8;
491 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
492 const struct pci_device_id *pci_id)
495 unsigned char pci_latency;
497 CX18_DEBUG_INFO("Enabling pci device\n");
499 if (pci_enable_device(dev)) {
500 CX18_ERR("Can't enable device %d!\n", cx->num);
503 if (pci_set_dma_mask(dev, 0xffffffff)) {
504 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
507 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
508 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
512 /* Check for bus mastering */
513 pci_read_config_word(dev, PCI_COMMAND, &cmd);
514 cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
515 pci_write_config_word(dev, PCI_COMMAND, cmd);
517 pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
518 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
520 if (pci_latency < 64 && cx18_pci_latency) {
521 CX18_INFO("Unreasonably low latency timer, "
522 "setting to 64 (was %d)\n", pci_latency);
523 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
524 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
526 /* This config space value relates to DMA latencies. The
527 default value 0x8080 is too low however and will lead
528 to DMA errors. 0xffff is the max value which solves
530 pci_write_config_dword(dev, 0x40, 0xffff);
532 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
533 "irq: %d, latency: %d, memory: 0x%lx\n",
534 cx->dev->device, cx->card_rev, dev->bus->number,
535 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
536 cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
542 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
543 const char *name, u32 id)
547 if (request_module(name) != 0) {
548 CX18_ERR("Failed to load module %s\n", name);
551 CX18_DEBUG_INFO("Loaded module %s\n", name);
556 static void cx18_load_and_init_modules(struct cx18 *cx)
558 u32 hw = cx->card->hw_all;
563 #ifndef CONFIG_MEDIA_TUNER
564 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
566 #ifndef CONFIG_VIDEO_CS5345
567 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
571 /* check which i2c devices are actually found */
572 for (i = 0; i < 32; i++) {
577 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
578 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
579 /* These 'devices' do not use i2c probing */
580 cx->hw_flags |= device;
583 cx18_i2c_register(cx, i);
584 if (cx18_i2c_hw_addr(cx, device) > 0)
585 cx->hw_flags |= device;
591 static int __devinit cx18_probe(struct pci_dev *dev,
592 const struct pci_device_id *pci_id)
599 spin_lock(&cx18_cards_lock);
601 /* Make sure we've got a place for this card */
602 if (cx18_cards_active == CX18_MAX_CARDS) {
603 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
605 spin_unlock(&cx18_cards_lock);
609 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
611 spin_unlock(&cx18_cards_lock);
614 cx18_cards[cx18_cards_active] = cx;
616 cx->num = cx18_cards_active++;
617 snprintf(cx->name, sizeof(cx->name) - 1, "cx18-%d", cx->num);
618 CX18_INFO("Initializing card #%d\n", cx->num);
620 spin_unlock(&cx18_cards_lock);
622 cx18_process_options(cx);
623 if (cx->options.cardtype == -1) {
627 if (cx18_init_struct1(cx)) {
632 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
634 /* PCI Device Setup */
635 retval = cx18_setup_pci(cx, dev, pci_id);
639 else if (retval == -ENXIO)
642 /* save cx in the pci struct for later use */
643 pci_set_drvdata(dev, cx);
646 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
647 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
648 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
651 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
652 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
656 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
657 devtype = read_reg(0xC72028);
658 switch (devtype & 0xff000000) {
660 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
663 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
666 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
670 cx18_init_power(cx, 1);
671 cx18_init_memory(cx);
673 cx->scb = (struct cx18_scb *)(cx->enc_mem + SCB_OFFSET);
679 CX18_DEBUG_INFO("activating i2c...\n");
680 if (init_cx18_i2c(cx)) {
681 CX18_ERR("Could not initialize i2c\n");
685 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
687 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
688 /* Based on the model number the cardtype may be changed.
689 The PCI IDs are not always reliable. */
690 cx18_process_eeprom(cx);
692 if (cx->card->comment)
693 CX18_INFO("%s", cx->card->comment);
694 if (cx->card->v4l2_capabilities == 0) {
698 cx18_init_memory(cx);
701 retval = request_irq(cx->dev->irq, cx18_irq_handler,
702 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
704 CX18_ERR("Failed to register irq %d\n", retval);
709 cx->std = V4L2_STD_NTSC_M;
711 if (cx->options.tuner == -1) {
714 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
715 if ((cx->std & cx->card->tuners[i].std) == 0)
717 cx->options.tuner = cx->card->tuners[i].tuner;
721 /* if no tuner was found, then pick the first tuner in the card list */
722 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
723 cx->std = cx->card->tuners[0].std;
724 cx->options.tuner = cx->card->tuners[0].tuner;
726 if (cx->options.radio == -1)
727 cx->options.radio = (cx->card->radio_input.audio_type != 0);
729 /* The card is now fully identified, continue with card-specific
731 cx18_init_struct2(cx);
733 cx18_load_and_init_modules(cx);
735 if (cx->std & V4L2_STD_525_60) {
742 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
744 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
745 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
746 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
747 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
748 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
749 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
751 if (cx->options.radio > 0)
752 cx->v4l2_cap |= V4L2_CAP_RADIO;
754 retval = cx18_streams_setup(cx);
756 CX18_ERR("Error %d setting up streams\n", retval);
759 retval = cx18_streams_register(cx);
761 CX18_ERR("Error %d registering devices\n", retval);
765 if (cx->options.tuner > -1) {
766 struct tuner_setup setup;
768 setup.addr = ADDR_UNSET;
769 setup.type = cx->options.tuner;
770 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
771 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
772 cx18_reset_tuner_gpio : NULL;
773 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
774 if (setup.type == TUNER_XC2028) {
775 static struct xc2028_ctrl ctrl = {
776 .fname = XC2028_DEFAULT_FIRMWARE,
779 struct v4l2_priv_tun_config cfg = {
780 .tuner = cx->options.tuner,
783 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
787 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
789 cx->tuner_std = cx->std;
791 cx18_init_on_first_open(cx);
793 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
798 cx18_streams_cleanup(cx, 1);
800 free_irq(cx->dev->irq, (void *)cx);
806 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
811 CX18_ERR("Error %d on initialization\n", retval);
813 kfree(cx18_cards[cx18_cards_active]);
814 cx18_cards[cx18_cards_active] = NULL;
818 int cx18_init_on_first_open(struct cx18 *cx)
821 int fw_retry_count = 3;
822 struct v4l2_frequency vf;
824 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
827 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
830 while (--fw_retry_count > 0) {
832 if (cx18_firmware_init(cx) == 0)
834 if (fw_retry_count > 1)
835 CX18_WARN("Retry loading firmware\n");
838 if (fw_retry_count == 0) {
839 set_bit(CX18_F_I_FAILED, &cx->i_flags);
842 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
844 /* Init the firmware twice to work around a silicon bug
845 * transport related. */
848 while (--fw_retry_count > 0) {
850 if (cx18_firmware_init(cx) == 0)
852 if (fw_retry_count > 1)
853 CX18_WARN("Retry loading firmware\n");
856 if (fw_retry_count == 0) {
857 set_bit(CX18_F_I_FAILED, &cx->i_flags);
862 vf.type = V4L2_TUNER_ANALOG_TV;
863 vf.frequency = 6400; /* the tuner 'baseline' frequency */
865 /* Set initial frequency. For PAL/SECAM broadcasts no
866 'default' channel exists AFAIK. */
867 if (cx->std == V4L2_STD_NTSC_M_JP)
868 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
869 else if (cx->std & V4L2_STD_NTSC_M)
870 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
872 video_input = cx->active_input;
873 cx->active_input++; /* Force update of input */
874 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_INPUT, &video_input);
876 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
878 cx->std++; /* Force full standard initialization */
879 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_STD, &cx->tuner_std);
880 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_FREQUENCY, &vf);
884 static void cx18_remove(struct pci_dev *pci_dev)
886 struct cx18 *cx = pci_get_drvdata(pci_dev);
888 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
890 /* Stop all captures */
891 CX18_DEBUG_INFO("Stopping all streams\n");
892 if (atomic_read(&cx->capturing) > 0)
893 cx18_stop_all_captures(cx);
896 sw1_irq_disable(IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
897 sw2_irq_disable(IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
899 cx18_halt_firmware(cx);
901 cx18_streams_cleanup(cx, 1);
905 free_irq(cx->dev->irq, (void *)cx);
909 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
911 pci_disable_device(cx->dev);
913 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
916 /* define a pci_driver for card detection */
917 static struct pci_driver cx18_pci_driver = {
919 .id_table = cx18_pci_tbl,
921 .remove = cx18_remove,
924 static int module_start(void)
926 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
928 memset(cx18_cards, 0, sizeof(cx18_cards));
930 /* Validate parameters */
931 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
932 printk(KERN_ERR "cx18: Exiting, ivtv_first_minor must be between 0 and %d\n",
937 if (cx18_debug < 0 || cx18_debug > 511) {
939 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
942 if (pci_register_driver(&cx18_pci_driver)) {
943 printk(KERN_ERR "cx18: Error detecting PCI card\n");
946 printk(KERN_INFO "cx18: End initialization\n");
950 static void module_cleanup(void)
954 pci_unregister_driver(&cx18_pci_driver);
956 for (i = 0; i < cx18_cards_active; i++) {
957 if (cx18_cards[i] == NULL)
959 kfree(cx18_cards[i]);
963 module_init(module_start);
964 module_exit(module_cleanup);