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 int cx18_waitq(wait_queue_head_t *waitq)
171 prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
173 finish_wait(waitq, &wait);
174 return signal_pending(current) ? -EINTR : 0;
177 /* Generic utility functions */
178 int cx18_msleep_timeout(unsigned int msecs, int intr)
180 int timeout = msecs_to_jiffies(msecs);
184 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
185 timeout = schedule_timeout(timeout);
186 sig = intr ? signal_pending(current) : 0;
187 } while (!sig && timeout);
191 /* Release ioremapped memory */
192 static void cx18_iounmap(struct cx18 *cx)
197 /* Release io memory */
198 if (cx->enc_mem != NULL) {
199 CX18_DEBUG_INFO("releasing enc_mem\n");
200 iounmap(cx->enc_mem);
205 /* Hauppauge card? get values from tveeprom */
206 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
210 cx->i2c_client[0].addr = 0xA0 >> 1;
211 tveeprom_read(&cx->i2c_client[0], eedata, sizeof(eedata));
212 tveeprom_hauppauge_analog(&cx->i2c_client[0], tv, eedata);
215 static void cx18_process_eeprom(struct cx18 *cx)
219 cx18_read_eeprom(cx, &tv);
221 /* Many thanks to Steven Toth from Hauppauge for providing the
224 case 74000 ... 74099:
225 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
227 case 74700 ... 74799:
228 cx->card = cx18_get_card(CX18_CARD_HVR_1600_SAMSUNG);
231 CX18_ERR("Invalid EEPROM\n");
234 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
235 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
239 cx->v4l2_cap = cx->card->v4l2_capabilities;
240 cx->card_name = cx->card->name;
241 cx->card_i2c = cx->card->i2c;
243 CX18_INFO("Autodetected %s\n", cx->card_name);
245 if (tv.tuner_type == TUNER_ABSENT)
246 CX18_ERR("tveeprom cannot autodetect tuner!");
248 if (cx->options.tuner == -1)
249 cx->options.tuner = tv.tuner_type;
250 if (cx->options.radio == -1)
251 cx->options.radio = (tv.has_radio != 0);
254 /* user specified tuner standard */
257 /* autodetect tuner standard */
258 if (tv.tuner_formats & V4L2_STD_PAL) {
259 CX18_DEBUG_INFO("PAL tuner detected\n");
260 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
261 } else if (tv.tuner_formats & V4L2_STD_NTSC) {
262 CX18_DEBUG_INFO("NTSC tuner detected\n");
263 cx->std |= V4L2_STD_NTSC_M;
264 } else if (tv.tuner_formats & V4L2_STD_SECAM) {
265 CX18_DEBUG_INFO("SECAM tuner detected\n");
266 cx->std |= V4L2_STD_SECAM_L;
268 CX18_INFO("No tuner detected, default to NTSC-M\n");
269 cx->std |= V4L2_STD_NTSC_M;
273 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
277 return V4L2_STD_PAL_60;
282 return V4L2_STD_PAL_BG;
285 return V4L2_STD_PAL_H;
288 if (pal[1] == 'c' || pal[1] == 'C')
289 return V4L2_STD_PAL_Nc;
290 return V4L2_STD_PAL_N;
293 return V4L2_STD_PAL_I;
298 return V4L2_STD_PAL_DK;
301 return V4L2_STD_PAL_M;
305 CX18_WARN("pal= argument not recognised\n");
316 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
321 return V4L2_STD_SECAM_DK;
324 if (secam[1] == 'C' || secam[1] == 'c')
325 return V4L2_STD_SECAM_LC;
326 return V4L2_STD_SECAM_L;
330 CX18_WARN("secam= argument not recognised\n");
337 return V4L2_STD_NTSC_M;
340 return V4L2_STD_NTSC_M_JP;
343 return V4L2_STD_NTSC_M_KR;
347 CX18_WARN("ntsc= argument not recognised\n");
355 static void cx18_process_options(struct cx18 *cx)
359 cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
360 cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
361 cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
362 cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
363 cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
364 cx->options.cardtype = cardtype[cx->num];
365 cx->options.tuner = tuner[cx->num];
366 cx->options.radio = radio[cx->num];
368 cx->std = cx18_parse_std(cx);
369 if (cx->options.cardtype == -1) {
370 CX18_INFO("Ignore card\n");
373 cx->card = cx18_get_card(cx->options.cardtype - 1);
375 CX18_INFO("User specified %s card\n", cx->card->name);
376 else if (cx->options.cardtype != 0)
377 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
378 if (cx->card == NULL) {
379 if (cx->dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
380 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
381 CX18_INFO("Autodetected Hauppauge card\n");
384 if (cx->card == NULL) {
385 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
386 if (cx->card->pci_list == NULL)
388 for (j = 0; cx->card->pci_list[j].device; j++) {
389 if (cx->dev->device !=
390 cx->card->pci_list[j].device)
392 if (cx->dev->subsystem_vendor !=
393 cx->card->pci_list[j].subsystem_vendor)
395 if (cx->dev->subsystem_device !=
396 cx->card->pci_list[j].subsystem_device)
398 CX18_INFO("Autodetected %s card\n", cx->card->name);
405 if (cx->card == NULL) {
406 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
407 CX18_ERR("Unknown card: vendor/device: %04x/%04x\n",
408 cx->dev->vendor, cx->dev->device);
409 CX18_ERR(" subsystem vendor/device: %04x/%04x\n",
410 cx->dev->subsystem_vendor, cx->dev->subsystem_device);
411 CX18_ERR("Defaulting to %s card\n", cx->card->name);
412 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
413 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
414 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
416 cx->v4l2_cap = cx->card->v4l2_capabilities;
417 cx->card_name = cx->card->name;
418 cx->card_i2c = cx->card->i2c;
421 /* Precondition: the cx18 structure has been memset to 0. Only
422 the dev and num fields have been filled in.
423 No assumptions on the card type may be made here (see cx18_init_struct2
426 static int __devinit cx18_init_struct1(struct cx18 *cx)
428 cx->base_addr = pci_resource_start(cx->dev, 0);
430 mutex_init(&cx->serialize_lock);
431 mutex_init(&cx->i2c_bus_lock[0]);
432 mutex_init(&cx->i2c_bus_lock[1]);
434 spin_lock_init(&cx->lock);
435 spin_lock_init(&cx->dma_reg_lock);
437 /* start counting open_id at 1 */
440 /* Initial settings */
441 cx2341x_fill_defaults(&cx->params);
442 cx->temporal_strength = cx->params.video_temporal_filter;
443 cx->spatial_strength = cx->params.video_spatial_filter;
444 cx->filter_mode = cx->params.video_spatial_filter_mode |
445 (cx->params.video_temporal_filter_mode << 1) |
446 (cx->params.video_median_filter_type << 2);
447 cx->params.port = CX2341X_PORT_MEMORY;
448 cx->params.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
449 init_waitqueue_head(&cx->cap_w);
450 init_waitqueue_head(&cx->mb_apu_waitq);
451 init_waitqueue_head(&cx->mb_cpu_waitq);
452 init_waitqueue_head(&cx->mb_epu_waitq);
453 init_waitqueue_head(&cx->mb_hpu_waitq);
454 init_waitqueue_head(&cx->dma_waitq);
457 cx->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
458 cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
459 cx->vbi.raw_size = 1456;
460 cx->vbi.raw_decoder_line_size = 1456;
461 cx->vbi.raw_decoder_sav_odd_field = 0x20;
462 cx->vbi.raw_decoder_sav_even_field = 0x60;
463 cx->vbi.sliced_decoder_line_size = 272;
464 cx->vbi.sliced_decoder_sav_odd_field = 0xB0;
465 cx->vbi.sliced_decoder_sav_even_field = 0xF0;
469 /* Second initialization part. Here the card type has been
471 static void __devinit cx18_init_struct2(struct cx18 *cx)
475 for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
476 if (cx->card->video_inputs[i].video_type == 0)
479 for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
480 if (cx->card->audio_inputs[i].audio_type == 0)
482 cx->nof_audio_inputs = i;
484 /* Find tuner input */
485 for (i = 0; i < cx->nof_inputs; i++) {
486 if (cx->card->video_inputs[i].video_type ==
487 CX18_CARD_INPUT_VID_TUNER)
490 if (i == cx->nof_inputs)
492 cx->active_input = i;
493 cx->audio_input = cx->card->video_inputs[i].audio_index;
494 cx->av_state.vid_input = CX18_AV_COMPOSITE7;
495 cx->av_state.aud_input = CX18_AV_AUDIO8;
496 cx->av_state.audclk_freq = 48000;
497 cx->av_state.audmode = V4L2_TUNER_MODE_LANG1;
498 cx->av_state.vbi_line_offset = 8;
501 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *dev,
502 const struct pci_device_id *pci_id)
505 unsigned char pci_latency;
507 CX18_DEBUG_INFO("Enabling pci device\n");
509 if (pci_enable_device(dev)) {
510 CX18_ERR("Can't enable device %d!\n", cx->num);
513 if (pci_set_dma_mask(dev, 0xffffffff)) {
514 CX18_ERR("No suitable DMA available on card %d.\n", cx->num);
517 if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
518 CX18_ERR("Cannot request encoder memory region on card %d.\n", cx->num);
522 /* Check for bus mastering */
523 pci_read_config_word(dev, PCI_COMMAND, &cmd);
524 cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
525 pci_write_config_word(dev, PCI_COMMAND, cmd);
527 pci_read_config_byte(dev, PCI_CLASS_REVISION, &cx->card_rev);
528 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
530 if (pci_latency < 64 && cx18_pci_latency) {
531 CX18_INFO("Unreasonably low latency timer, "
532 "setting to 64 (was %d)\n", pci_latency);
533 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
534 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
536 /* This config space value relates to DMA latencies. The
537 default value 0x8080 is too low however and will lead
538 to DMA errors. 0xffff is the max value which solves
540 pci_write_config_dword(dev, 0x40, 0xffff);
542 CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
543 "irq: %d, latency: %d, memory: 0x%lx\n",
544 cx->dev->device, cx->card_rev, dev->bus->number,
545 PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
546 cx->dev->irq, pci_latency, (unsigned long)cx->base_addr);
551 static u32 cx18_request_module(struct cx18 *cx, u32 hw,
552 const char *name, u32 id)
556 if (request_module(name) != 0) {
557 CX18_ERR("Failed to load module %s\n", name);
560 CX18_DEBUG_INFO("Loaded module %s\n", name);
564 static void cx18_load_and_init_modules(struct cx18 *cx)
566 u32 hw = cx->card->hw_all;
570 #ifndef CONFIG_MEDIA_TUNER
571 hw = cx18_request_module(cx, hw, "tuner", CX18_HW_TUNER);
573 #ifndef CONFIG_VIDEO_CS5345
574 hw = cx18_request_module(cx, hw, "cs5345", CX18_HW_CS5345);
577 /* check which i2c devices are actually found */
578 for (i = 0; i < 32; i++) {
583 if (device == CX18_HW_GPIO || device == CX18_HW_TVEEPROM ||
584 device == CX18_HW_CX23418 || device == CX18_HW_DVB) {
585 /* These 'devices' do not use i2c probing */
586 cx->hw_flags |= device;
589 cx18_i2c_register(cx, i);
590 if (cx18_i2c_hw_addr(cx, device) > 0)
591 cx->hw_flags |= device;
597 static int __devinit cx18_probe(struct pci_dev *dev,
598 const struct pci_device_id *pci_id)
605 spin_lock(&cx18_cards_lock);
607 /* Make sure we've got a place for this card */
608 if (cx18_cards_active == CX18_MAX_CARDS) {
609 printk(KERN_ERR "cx18: Maximum number of cards detected (%d).\n",
611 spin_unlock(&cx18_cards_lock);
615 cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
617 spin_unlock(&cx18_cards_lock);
620 cx18_cards[cx18_cards_active] = cx;
622 cx->num = cx18_cards_active++;
623 snprintf(cx->name, sizeof(cx->name) - 1, "cx18-%d", cx->num);
624 CX18_INFO("Initializing card #%d\n", cx->num);
626 spin_unlock(&cx18_cards_lock);
628 cx18_process_options(cx);
629 if (cx->options.cardtype == -1) {
633 if (cx18_init_struct1(cx)) {
638 CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
640 /* PCI Device Setup */
641 retval = cx18_setup_pci(cx, dev, pci_id);
645 else if (retval == -ENXIO)
648 /* save cx in the pci struct for later use */
649 pci_set_drvdata(dev, cx);
652 CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
653 cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
654 cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
657 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
658 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
662 cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
663 devtype = read_reg(0xC72028);
664 switch (devtype & 0xff000000) {
666 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
669 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
672 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
676 cx18_init_power(cx, 1);
677 cx18_init_memory(cx);
679 cx->scb = (struct cx18_scb *)(cx->enc_mem + SCB_OFFSET);
685 CX18_DEBUG_INFO("activating i2c...\n");
686 if (init_cx18_i2c(cx)) {
687 CX18_ERR("Could not initialize i2c\n");
691 CX18_DEBUG_INFO("Active card count: %d.\n", cx18_cards_active);
693 if (cx->card->hw_all & CX18_HW_TVEEPROM) {
694 /* Based on the model number the cardtype may be changed.
695 The PCI IDs are not always reliable. */
696 cx18_process_eeprom(cx);
698 if (cx->card->comment)
699 CX18_INFO("%s", cx->card->comment);
700 if (cx->card->v4l2_capabilities == 0) {
704 cx18_init_memory(cx);
707 retval = request_irq(cx->dev->irq, cx18_irq_handler,
708 IRQF_SHARED | IRQF_DISABLED, cx->name, (void *)cx);
710 CX18_ERR("Failed to register irq %d\n", retval);
715 cx->std = V4L2_STD_NTSC_M;
717 if (cx->options.tuner == -1) {
720 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
721 if ((cx->std & cx->card->tuners[i].std) == 0)
723 cx->options.tuner = cx->card->tuners[i].tuner;
727 /* if no tuner was found, then pick the first tuner in the card list */
728 if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
729 cx->std = cx->card->tuners[0].std;
730 cx->options.tuner = cx->card->tuners[0].tuner;
732 if (cx->options.radio == -1)
733 cx->options.radio = (cx->card->radio_input.audio_type != 0);
735 /* The card is now fully identified, continue with card-specific
737 cx18_init_struct2(cx);
739 cx18_load_and_init_modules(cx);
741 if (cx->std & V4L2_STD_525_60) {
748 cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
750 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = 0x08000;
751 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = 0x08000;
752 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = 0x01200;
753 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = 0x20000;
754 vbi_buf_size = cx->vbi.raw_size * (cx->is_60hz ? 24 : 36) / 2;
755 cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
757 if (cx->options.radio > 0)
758 cx->v4l2_cap |= V4L2_CAP_RADIO;
760 retval = cx18_streams_setup(cx);
762 CX18_ERR("Error %d setting up streams\n", retval);
765 retval = cx18_streams_register(cx);
767 CX18_ERR("Error %d registering devices\n", retval);
771 if (cx->options.tuner > -1) {
772 struct tuner_setup setup;
774 setup.addr = ADDR_UNSET;
775 setup.type = cx->options.tuner;
776 setup.mode_mask = T_ANALOG_TV; /* matches TV tuners */
777 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
778 cx18_reset_tuner_gpio : NULL;
779 cx18_call_i2c_clients(cx, TUNER_SET_TYPE_ADDR, &setup);
780 if (setup.type == TUNER_XC2028) {
781 static struct xc2028_ctrl ctrl = {
782 .fname = XC2028_DEFAULT_FIRMWARE,
785 struct v4l2_priv_tun_config cfg = {
786 .tuner = cx->options.tuner,
789 cx18_call_i2c_clients(cx, TUNER_SET_CONFIG, &cfg);
793 /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
795 cx->tuner_std = cx->std;
797 cx18_init_on_first_open(cx);
799 CX18_INFO("Initialized card #%d: %s\n", cx->num, cx->card_name);
804 cx18_streams_cleanup(cx);
806 free_irq(cx->dev->irq, (void *)cx);
812 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
817 CX18_ERR("Error %d on initialization\n", retval);
819 kfree(cx18_cards[cx18_cards_active]);
820 cx18_cards[cx18_cards_active] = NULL;
824 int cx18_init_on_first_open(struct cx18 *cx)
827 int fw_retry_count = 3;
828 struct v4l2_frequency vf;
830 if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
833 if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
836 while (--fw_retry_count > 0) {
838 if (cx18_firmware_init(cx) == 0)
840 if (fw_retry_count > 1)
841 CX18_WARN("Retry loading firmware\n");
844 if (fw_retry_count == 0) {
845 set_bit(CX18_F_I_FAILED, &cx->i_flags);
848 set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
850 /* Init the firmware twice to work around a silicon bug
851 * transport related. */
854 while (--fw_retry_count > 0) {
856 if (cx18_firmware_init(cx) == 0)
858 if (fw_retry_count > 1)
859 CX18_WARN("Retry loading firmware\n");
862 if (fw_retry_count == 0) {
863 set_bit(CX18_F_I_FAILED, &cx->i_flags);
868 vf.type = V4L2_TUNER_ANALOG_TV;
869 vf.frequency = 6400; /* the tuner 'baseline' frequency */
871 /* Set initial frequency. For PAL/SECAM broadcasts no
872 'default' channel exists AFAIK. */
873 if (cx->std == V4L2_STD_NTSC_M_JP)
874 vf.frequency = 1460; /* ch. 1 91250*16/1000 */
875 else if (cx->std & V4L2_STD_NTSC_M)
876 vf.frequency = 1076; /* ch. 4 67250*16/1000 */
878 video_input = cx->active_input;
879 cx->active_input++; /* Force update of input */
880 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_INPUT, &video_input);
882 /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
884 cx->std++; /* Force full standard initialization */
885 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_STD, &cx->tuner_std);
886 cx18_v4l2_ioctls(cx, NULL, VIDIOC_S_FREQUENCY, &vf);
890 static void cx18_remove(struct pci_dev *pci_dev)
892 struct cx18 *cx = pci_get_drvdata(pci_dev);
894 CX18_DEBUG_INFO("Removing Card #%d\n", cx->num);
896 /* Stop all captures */
897 CX18_DEBUG_INFO("Stopping all streams\n");
898 if (atomic_read(&cx->capturing) > 0)
899 cx18_stop_all_captures(cx);
902 sw1_irq_disable(IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
903 sw2_irq_disable(IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
905 cx18_halt_firmware(cx);
907 cx18_streams_cleanup(cx);
911 free_irq(cx->dev->irq, (void *)cx);
916 release_mem_region(cx->base_addr, CX18_MEM_SIZE);
918 pci_disable_device(cx->dev);
920 CX18_INFO("Removed %s, card #%d\n", cx->card_name, cx->num);
923 /* define a pci_driver for card detection */
924 static struct pci_driver cx18_pci_driver = {
926 .id_table = cx18_pci_tbl,
928 .remove = cx18_remove,
931 static int module_start(void)
933 printk(KERN_INFO "cx18: Start initialization, version %s\n", CX18_VERSION);
935 memset(cx18_cards, 0, sizeof(cx18_cards));
937 /* Validate parameters */
938 if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
939 printk(KERN_ERR "cx18: Exiting, ivtv_first_minor must be between 0 and %d\n",
944 if (cx18_debug < 0 || cx18_debug > 511) {
946 printk(KERN_INFO "cx18: Debug value must be >= 0 and <= 511!\n");
949 if (pci_register_driver(&cx18_pci_driver)) {
950 printk(KERN_ERR "cx18: Error detecting PCI card\n");
953 printk(KERN_INFO "cx18: End initialization\n");
957 static void module_cleanup(void)
961 pci_unregister_driver(&cx18_pci_driver);
963 for (i = 0; i < cx18_cards_active; i++) {
964 if (cx18_cards[i] == NULL)
966 kfree(cx18_cards[i]);
970 module_init(module_start);
971 module_exit(module_cleanup);