Back to home page

OSCL-LXR
 
 

     

0001 /*
0002     ivtv driver initialization and card probing
0003     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
0004     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
0005     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
0006 
0007     This program is free software; you can redistribute it and/or modify
0008     it under the terms of the GNU General Public License as published by
0009     the Free Software Foundation; either version 2 of the License, or
0010     (at your option) any later version.
0011 
0012     This program is distributed in the hope that it will be useful,
0013     but WITHOUT ANY WARRANTY; without even the implied warranty of
0014     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0015     GNU General Public License for more details.
0016 
0017     You should have received a copy of the GNU General Public License
0018     along with this program; if not, write to the Free Software
0019     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
0020  */
0021 
0022 /* Main Driver file for the ivtv project:
0023  * Driver for the Conexant CX23415/CX23416 chip.
0024  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
0025  * License: GPL
0026  *
0027  * -----
0028  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
0029  *                      and Takeru KOMORIYA<komoriya@paken.org>
0030  *
0031  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
0032  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
0033  *
0034  * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
0035  *                using information from T.Adachi,Takeru KOMORIYA and others :-)
0036  *
0037  * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
0038  *                version by T.Adachi. Special thanks  Mr.Suzuki
0039  */
0040 
0041 #include "ivtv-driver.h"
0042 #include "ivtv-version.h"
0043 #include "ivtv-fileops.h"
0044 #include "ivtv-i2c.h"
0045 #include "ivtv-firmware.h"
0046 #include "ivtv-queue.h"
0047 #include "ivtv-udma.h"
0048 #include "ivtv-irq.h"
0049 #include "ivtv-mailbox.h"
0050 #include "ivtv-streams.h"
0051 #include "ivtv-ioctl.h"
0052 #include "ivtv-cards.h"
0053 #include "ivtv-vbi.h"
0054 #include "ivtv-routing.h"
0055 #include "ivtv-controls.h"
0056 #include "ivtv-gpio.h"
0057 #include <linux/dma-mapping.h>
0058 #include <media/tveeprom.h>
0059 #include <media/i2c/saa7115.h>
0060 #include "xc2028.h"
0061 #include <uapi/linux/sched/types.h>
0062 
0063 /* If you have already X v4l cards, then set this to X. This way
0064    the device numbers stay matched. Example: you have a WinTV card
0065    without radio and a PVR-350 with. Normally this would give a
0066    video1 device together with a radio0 device for the PVR. By
0067    setting this to 1 you ensure that radio0 is now also radio1. */
0068 int ivtv_first_minor;
0069 
0070 /* Callback for registering extensions */
0071 int (*ivtv_ext_init)(struct ivtv *);
0072 EXPORT_SYMBOL(ivtv_ext_init);
0073 
0074 /* add your revision and whatnot here */
0075 static const struct pci_device_id ivtv_pci_tbl[] = {
0076     {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
0077      PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
0078     {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
0079      PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
0080     {0,}
0081 };
0082 
0083 MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
0084 
0085 /* ivtv instance counter */
0086 static atomic_t ivtv_instance = ATOMIC_INIT(0);
0087 
0088 /* Parameter declarations */
0089 static int cardtype[IVTV_MAX_CARDS];
0090 static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
0091                      -1, -1, -1, -1, -1, -1, -1, -1,
0092                      -1, -1, -1, -1, -1, -1, -1, -1,
0093                      -1, -1, -1, -1, -1, -1, -1, -1 };
0094 static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
0095                      -1, -1, -1, -1, -1, -1, -1, -1,
0096                      -1, -1, -1, -1, -1, -1, -1, -1,
0097                      -1, -1, -1, -1, -1, -1, -1, -1 };
0098 static int i2c_clock_period[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
0099                            -1, -1, -1, -1, -1, -1, -1, -1,
0100                            -1, -1, -1, -1, -1, -1, -1, -1,
0101                            -1, -1, -1, -1, -1, -1, -1, -1 };
0102 
0103 static unsigned int cardtype_c = 1;
0104 static unsigned int tuner_c = 1;
0105 static int radio_c = 1;
0106 static unsigned int i2c_clock_period_c = 1;
0107 static char pal[] = "---";
0108 static char secam[] = "--";
0109 static char ntsc[] = "-";
0110 
0111 /* Buffers */
0112 
0113 /* DMA Buffers, Default size in MB allocated */
0114 #define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
0115 #define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
0116 #define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
0117 /* Exception: size in kB for this stream (MB is overkill) */
0118 #define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
0119 #define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
0120 #define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
0121 /* Exception: size in kB for this stream (MB is way overkill) */
0122 #define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
0123 
0124 static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
0125 static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
0126 static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
0127 static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
0128 static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
0129 static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
0130 static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
0131 
0132 static int ivtv_yuv_mode;
0133 static int ivtv_yuv_threshold = -1;
0134 static int ivtv_pci_latency = 1;
0135 
0136 int ivtv_debug;
0137 #ifdef CONFIG_VIDEO_ADV_DEBUG
0138 int ivtv_fw_debug;
0139 #endif
0140 
0141 static int tunertype = -1;
0142 static int newi2c = -1;
0143 
0144 module_param_array(tuner, int, &tuner_c, 0644);
0145 module_param_array(radio, int, &radio_c, 0644);
0146 module_param_array(cardtype, int, &cardtype_c, 0644);
0147 module_param_string(pal, pal, sizeof(pal), 0644);
0148 module_param_string(secam, secam, sizeof(secam), 0644);
0149 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
0150 module_param_named(debug,ivtv_debug, int, 0644);
0151 #ifdef CONFIG_VIDEO_ADV_DEBUG
0152 module_param_named(fw_debug, ivtv_fw_debug, int, 0644);
0153 #endif
0154 module_param(ivtv_pci_latency, int, 0644);
0155 module_param(ivtv_yuv_mode, int, 0644);
0156 module_param(ivtv_yuv_threshold, int, 0644);
0157 module_param(ivtv_first_minor, int, 0644);
0158 
0159 module_param(enc_mpg_buffers, int, 0644);
0160 module_param(enc_yuv_buffers, int, 0644);
0161 module_param(enc_vbi_buffers, int, 0644);
0162 module_param(enc_pcm_buffers, int, 0644);
0163 module_param(dec_mpg_buffers, int, 0644);
0164 module_param(dec_yuv_buffers, int, 0644);
0165 module_param(dec_vbi_buffers, int, 0644);
0166 
0167 module_param(tunertype, int, 0644);
0168 module_param(newi2c, int, 0644);
0169 module_param_array(i2c_clock_period, int, &i2c_clock_period_c, 0644);
0170 
0171 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
0172             "\t\t\tsee tuner.h for values");
0173 MODULE_PARM_DESC(radio,
0174          "Enable or disable the radio. Use only if autodetection\n"
0175          "\t\t\tfails. 0 = disable, 1 = enable");
0176 MODULE_PARM_DESC(cardtype,
0177          "Only use this option if your card is not detected properly.\n"
0178          "\t\tSpecify card type:\n"
0179          "\t\t\t 1 = WinTV PVR 250\n"
0180          "\t\t\t 2 = WinTV PVR 350\n"
0181          "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
0182          "\t\t\t 4 = AVerMedia M179\n"
0183          "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
0184          "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
0185          "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
0186          "\t\t\t 8 = Adaptec AVC-2410\n"
0187          "\t\t\t 9 = Adaptec AVC-2010\n"
0188          "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
0189          "\t\t\t11 = AOpen VA2000MAX-STN6\n"
0190          "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
0191          "\t\t\t13 = I/O Data GV-MVP/RX\n"
0192          "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
0193          "\t\t\t15 = GOTVIEW PCI DVD\n"
0194          "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
0195          "\t\t\t17 = Yuan MPC622\n"
0196          "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
0197          "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
0198          "\t\t\t20 = Club3D ZAP-TV1x01\n"
0199          "\t\t\t21 = AverTV MCE 116 Plus\n"
0200          "\t\t\t22 = ASUS Falcon2\n"
0201          "\t\t\t23 = AverMedia PVR-150 Plus\n"
0202          "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
0203          "\t\t\t25 = AverMedia M104 (not yet working)\n"
0204          "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
0205          "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
0206          "\t\t\t28 = Sony VAIO Giga Pocket (ENX Kikyou)\n"
0207          "\t\t\t 0 = Autodetect (default)\n"
0208          "\t\t\t-1 = Ignore this card\n\t\t");
0209 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
0210 MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
0211 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
0212 MODULE_PARM_DESC(tunertype,
0213         "Specify tuner type:\n"
0214         "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
0215         "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
0216         "\t\t\t-1 = Autodetect (default)\n");
0217 MODULE_PARM_DESC(debug,
0218          "Debug level (bitmask). Default: 0\n"
0219          "\t\t\t   1/0x0001: warning\n"
0220          "\t\t\t   2/0x0002: info\n"
0221          "\t\t\t   4/0x0004: mailbox\n"
0222          "\t\t\t   8/0x0008: ioctl\n"
0223          "\t\t\t  16/0x0010: file\n"
0224          "\t\t\t  32/0x0020: dma\n"
0225          "\t\t\t  64/0x0040: irq\n"
0226          "\t\t\t 128/0x0080: decoder\n"
0227          "\t\t\t 256/0x0100: yuv\n"
0228          "\t\t\t 512/0x0200: i2c\n"
0229          "\t\t\t1024/0x0400: high volume\n");
0230 #ifdef CONFIG_VIDEO_ADV_DEBUG
0231 MODULE_PARM_DESC(fw_debug,
0232          "Enable code for debugging firmware problems.  Default: 0\n");
0233 #endif
0234 MODULE_PARM_DESC(ivtv_pci_latency,
0235          "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
0236          "\t\t\tDefault: Yes");
0237 MODULE_PARM_DESC(ivtv_yuv_mode,
0238          "Specify the yuv playback mode:\n"
0239          "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
0240          "\t\t\tDefault: 0 (interlaced)");
0241 MODULE_PARM_DESC(ivtv_yuv_threshold,
0242          "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
0243          "\t\t\tDefault: 480");
0244 MODULE_PARM_DESC(enc_mpg_buffers,
0245          "Encoder MPG Buffers (in MB)\n"
0246          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
0247 MODULE_PARM_DESC(enc_yuv_buffers,
0248          "Encoder YUV Buffers (in MB)\n"
0249          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
0250 MODULE_PARM_DESC(enc_vbi_buffers,
0251          "Encoder VBI Buffers (in MB)\n"
0252          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
0253 MODULE_PARM_DESC(enc_pcm_buffers,
0254          "Encoder PCM buffers (in kB)\n"
0255          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
0256 MODULE_PARM_DESC(dec_mpg_buffers,
0257          "Decoder MPG buffers (in MB)\n"
0258          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
0259 MODULE_PARM_DESC(dec_yuv_buffers,
0260          "Decoder YUV buffers (in MB)\n"
0261          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
0262 MODULE_PARM_DESC(dec_vbi_buffers,
0263          "Decoder VBI buffers (in kB)\n"
0264          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
0265 MODULE_PARM_DESC(newi2c,
0266          "Use new I2C implementation\n"
0267          "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
0268          "\t\t\tDefault is autodetect");
0269 MODULE_PARM_DESC(i2c_clock_period,
0270          "Period of SCL for the I2C bus controlled by the CX23415/6\n"
0271          "\t\t\tMin: 10 usec (100 kHz), Max: 4500 usec (222 Hz)\n"
0272          "\t\t\tDefault: " __stringify(IVTV_DEFAULT_I2C_CLOCK_PERIOD));
0273 
0274 MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first card");
0275 
0276 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
0277 MODULE_DESCRIPTION("CX23415/CX23416 driver");
0278 MODULE_LICENSE("GPL");
0279 
0280 MODULE_VERSION(IVTV_VERSION);
0281 
0282 #if defined(CONFIG_MODULES) && defined(MODULE)
0283 static void request_module_async(struct work_struct *work)
0284 {
0285     struct ivtv *dev = container_of(work, struct ivtv, request_module_wk);
0286 
0287     /* Make sure ivtv-alsa module is loaded */
0288     request_module("ivtv-alsa");
0289 
0290     /* Initialize ivtv-alsa for this instance of the cx18 device */
0291     if (ivtv_ext_init != NULL)
0292         ivtv_ext_init(dev);
0293 }
0294 
0295 static void request_modules(struct ivtv *dev)
0296 {
0297     INIT_WORK(&dev->request_module_wk, request_module_async);
0298     schedule_work(&dev->request_module_wk);
0299 }
0300 
0301 static void flush_request_modules(struct ivtv *dev)
0302 {
0303     flush_work(&dev->request_module_wk);
0304 }
0305 #else
0306 #define request_modules(dev)
0307 #define flush_request_modules(dev)
0308 #endif /* CONFIG_MODULES */
0309 
0310 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
0311 {
0312     itv->irqmask &= ~mask;
0313     write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
0314 }
0315 
0316 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
0317 {
0318     itv->irqmask |= mask;
0319     write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
0320 }
0321 
0322 int ivtv_set_output_mode(struct ivtv *itv, int mode)
0323 {
0324     int old_mode;
0325 
0326     spin_lock(&itv->lock);
0327     old_mode = itv->output_mode;
0328     if (old_mode == 0)
0329     itv->output_mode = old_mode = mode;
0330     spin_unlock(&itv->lock);
0331     return old_mode;
0332 }
0333 
0334 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
0335 {
0336     switch (itv->output_mode) {
0337     case OUT_MPG:
0338         return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
0339     case OUT_YUV:
0340         return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
0341     default:
0342         return NULL;
0343     }
0344 }
0345 
0346 int ivtv_waitq(wait_queue_head_t *waitq)
0347 {
0348     DEFINE_WAIT(wait);
0349 
0350     prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
0351     schedule();
0352     finish_wait(waitq, &wait);
0353     return signal_pending(current) ? -EINTR : 0;
0354 }
0355 
0356 /* Generic utility functions */
0357 int ivtv_msleep_timeout(unsigned int msecs, int intr)
0358 {
0359     int timeout = msecs_to_jiffies(msecs);
0360 
0361     do {
0362         set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
0363         timeout = schedule_timeout(timeout);
0364         if (intr) {
0365             int ret = signal_pending(current);
0366 
0367             if (ret)
0368                 return ret;
0369         }
0370     } while (timeout);
0371     return 0;
0372 }
0373 
0374 /* Release ioremapped memory */
0375 static void ivtv_iounmap(struct ivtv *itv)
0376 {
0377     if (itv == NULL)
0378         return;
0379 
0380     /* Release registers memory */
0381     if (itv->reg_mem != NULL) {
0382         IVTV_DEBUG_INFO("releasing reg_mem\n");
0383         iounmap(itv->reg_mem);
0384         itv->reg_mem = NULL;
0385     }
0386     /* Release io memory */
0387     if (itv->has_cx23415 && itv->dec_mem != NULL) {
0388         IVTV_DEBUG_INFO("releasing dec_mem\n");
0389         iounmap(itv->dec_mem);
0390     }
0391     itv->dec_mem = NULL;
0392 
0393     /* Release io memory */
0394     if (itv->enc_mem != NULL) {
0395         IVTV_DEBUG_INFO("releasing enc_mem\n");
0396         iounmap(itv->enc_mem);
0397         itv->enc_mem = NULL;
0398     }
0399 }
0400 
0401 /* Hauppauge card? get values from tveeprom */
0402 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
0403 {
0404     u8 eedata[256];
0405 
0406     itv->i2c_client.addr = 0xA0 >> 1;
0407     tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
0408     tveeprom_hauppauge_analog(tv, eedata);
0409 }
0410 
0411 static void ivtv_process_eeprom(struct ivtv *itv)
0412 {
0413     struct tveeprom tv;
0414     int pci_slot = PCI_SLOT(itv->pdev->devfn);
0415 
0416     ivtv_read_eeprom(itv, &tv);
0417 
0418     /* Many thanks to Steven Toth from Hauppauge for providing the
0419        model numbers */
0420     switch (tv.model) {
0421         /* In a few cases the PCI subsystem IDs do not correctly
0422            identify the card. A better method is to check the
0423            model number from the eeprom instead. */
0424         case 30012 ... 30039:  /* Low profile PVR250 */
0425         case 32000 ... 32999:
0426         case 48000 ... 48099:  /* 48??? range are PVR250s with a cx23415 */
0427         case 48400 ... 48599:
0428             itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
0429             break;
0430         case 48100 ... 48399:
0431         case 48600 ... 48999:
0432             itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
0433             break;
0434         case 23000 ... 23999:  /* PVR500 */
0435         case 25000 ... 25999:  /* Low profile PVR150 */
0436         case 26000 ... 26999:  /* Regular PVR150 */
0437             itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
0438             break;
0439         case 0:
0440             IVTV_ERR("Invalid EEPROM\n");
0441             return;
0442         default:
0443             IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
0444             itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
0445             break;
0446     }
0447 
0448     switch (tv.model) {
0449         /* Old style PVR350 (with an saa7114) uses this input for
0450            the tuner. */
0451         case 48254:
0452             itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
0453             break;
0454         default:
0455             break;
0456     }
0457 
0458     itv->v4l2_cap = itv->card->v4l2_capabilities;
0459     itv->card_name = itv->card->name;
0460     itv->card_i2c = itv->card->i2c;
0461 
0462     /* If this is a PVR500 then it should be possible to detect whether it is the
0463        first or second unit by looking at the subsystem device ID: is bit 4 is
0464        set, then it is the second unit (according to info from Hauppauge).
0465 
0466        However, while this works for most cards, I have seen a few PVR500 cards
0467        where both units have the same subsystem ID.
0468 
0469        So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
0470        PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
0471        it is the second unit. It is possible that it is a different slot when ivtv is
0472        used in Xen, in that case I ignore this card here. The worst that can happen
0473        is that the card presents itself with a non-working radio device.
0474 
0475        This detection is needed since the eeprom reports incorrectly that a radio is
0476        present on the second unit. */
0477     if (tv.model / 1000 == 23) {
0478         static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
0479             .radio = { 0x60, I2C_CLIENT_END },
0480             .demod = { 0x43, I2C_CLIENT_END },
0481             .tv = { 0x61, I2C_CLIENT_END },
0482         };
0483 
0484         itv->card_name = "WinTV PVR 500";
0485         itv->card_i2c = &ivtv_i2c_radio;
0486         if (pci_slot == 8 || pci_slot == 9) {
0487             int is_first = (pci_slot & 1) == 0;
0488 
0489             itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
0490                             "WinTV PVR 500 (unit #2)";
0491             if (!is_first) {
0492                 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
0493                 tv.has_radio = 0;
0494             }
0495         }
0496     }
0497     IVTV_INFO("Autodetected %s\n", itv->card_name);
0498 
0499     switch (tv.tuner_hauppauge_model) {
0500         case 85:
0501         case 99:
0502         case 112:
0503             itv->pvr150_workaround = 1;
0504             break;
0505         default:
0506             break;
0507     }
0508     if (tv.tuner_type == TUNER_ABSENT)
0509         IVTV_ERR("tveeprom cannot autodetect tuner!\n");
0510 
0511     if (itv->options.tuner == -1)
0512         itv->options.tuner = tv.tuner_type;
0513     if (itv->options.radio == -1)
0514         itv->options.radio = (tv.has_radio != 0);
0515     /* only enable newi2c if an IR blaster is present */
0516     if (itv->options.newi2c == -1 && tv.has_ir) {
0517         itv->options.newi2c = (tv.has_ir & 4) ? 1 : 0;
0518         if (itv->options.newi2c) {
0519             IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
0520             exit_ivtv_i2c(itv);
0521             init_ivtv_i2c(itv);
0522         }
0523     }
0524 
0525     if (itv->std != 0)
0526         /* user specified tuner standard */
0527         return;
0528 
0529     /* autodetect tuner standard */
0530     if (tv.tuner_formats & V4L2_STD_PAL) {
0531         IVTV_DEBUG_INFO("PAL tuner detected\n");
0532         itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
0533     } else if (tv.tuner_formats & V4L2_STD_NTSC) {
0534         IVTV_DEBUG_INFO("NTSC tuner detected\n");
0535         itv->std |= V4L2_STD_NTSC_M;
0536     } else if (tv.tuner_formats & V4L2_STD_SECAM) {
0537         IVTV_DEBUG_INFO("SECAM tuner detected\n");
0538         itv->std |= V4L2_STD_SECAM_L;
0539     } else {
0540         IVTV_INFO("No tuner detected, default to NTSC-M\n");
0541         itv->std |= V4L2_STD_NTSC_M;
0542     }
0543 }
0544 
0545 static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
0546 {
0547     switch (pal[0]) {
0548         case '6':
0549             tunertype = 0;
0550             return V4L2_STD_PAL_60;
0551         case 'b':
0552         case 'B':
0553         case 'g':
0554         case 'G':
0555         case 'h':
0556         case 'H':
0557             tunertype = 0;
0558             return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
0559         case 'n':
0560         case 'N':
0561             tunertype = 1;
0562             if (pal[1] == 'c' || pal[1] == 'C')
0563                 return V4L2_STD_PAL_Nc;
0564             return V4L2_STD_PAL_N;
0565         case 'i':
0566         case 'I':
0567             tunertype = 0;
0568             return V4L2_STD_PAL_I;
0569         case 'd':
0570         case 'D':
0571         case 'k':
0572         case 'K':
0573             tunertype = 0;
0574             return V4L2_STD_PAL_DK;
0575         case 'M':
0576         case 'm':
0577             tunertype = 1;
0578             return V4L2_STD_PAL_M;
0579         case '-':
0580             break;
0581         default:
0582             IVTV_WARN("pal= argument not recognised\n");
0583             return 0;
0584     }
0585 
0586     switch (secam[0]) {
0587         case 'b':
0588         case 'B':
0589         case 'g':
0590         case 'G':
0591         case 'h':
0592         case 'H':
0593             tunertype = 0;
0594             return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
0595         case 'd':
0596         case 'D':
0597         case 'k':
0598         case 'K':
0599             tunertype = 0;
0600             return V4L2_STD_SECAM_DK;
0601         case 'l':
0602         case 'L':
0603             tunertype = 0;
0604             if (secam[1] == 'C' || secam[1] == 'c')
0605                 return V4L2_STD_SECAM_LC;
0606             return V4L2_STD_SECAM_L;
0607         case '-':
0608             break;
0609         default:
0610             IVTV_WARN("secam= argument not recognised\n");
0611             return 0;
0612     }
0613 
0614     switch (ntsc[0]) {
0615         case 'm':
0616         case 'M':
0617             tunertype = 1;
0618             return V4L2_STD_NTSC_M;
0619         case 'j':
0620         case 'J':
0621             tunertype = 1;
0622             return V4L2_STD_NTSC_M_JP;
0623         case 'k':
0624         case 'K':
0625             tunertype = 1;
0626             return V4L2_STD_NTSC_M_KR;
0627         case '-':
0628             break;
0629         default:
0630             IVTV_WARN("ntsc= argument not recognised\n");
0631             return 0;
0632     }
0633 
0634     /* no match found */
0635     return 0;
0636 }
0637 
0638 static void ivtv_process_options(struct ivtv *itv)
0639 {
0640     const char *chipname;
0641     int i, j;
0642 
0643     itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
0644     itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
0645     itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
0646     itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
0647     itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
0648     itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
0649     itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
0650     itv->options.cardtype = cardtype[itv->instance];
0651     itv->options.tuner = tuner[itv->instance];
0652     itv->options.radio = radio[itv->instance];
0653 
0654     itv->options.i2c_clock_period = i2c_clock_period[itv->instance];
0655     if (itv->options.i2c_clock_period == -1)
0656         itv->options.i2c_clock_period = IVTV_DEFAULT_I2C_CLOCK_PERIOD;
0657     else if (itv->options.i2c_clock_period < 10)
0658         itv->options.i2c_clock_period = 10;
0659     else if (itv->options.i2c_clock_period > 4500)
0660         itv->options.i2c_clock_period = 4500;
0661 
0662     itv->options.newi2c = newi2c;
0663     if (tunertype < -1 || tunertype > 1) {
0664         IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
0665         tunertype = -1;
0666     }
0667     itv->std = ivtv_parse_std(itv);
0668     if (itv->std == 0 && tunertype >= 0)
0669         itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
0670     itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
0671     chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
0672     if (itv->options.cardtype == -1) {
0673         IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
0674         return;
0675     }
0676     if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
0677         IVTV_INFO("User specified %s card (detected %s based chip)\n",
0678                 itv->card->name, chipname);
0679     } else if (itv->options.cardtype != 0) {
0680         IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
0681     }
0682     if (itv->card == NULL) {
0683         if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
0684             itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
0685             itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
0686             itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
0687             IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
0688                     chipname);
0689         }
0690     }
0691     if (itv->card == NULL) {
0692         for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
0693             if (itv->card->pci_list == NULL)
0694                 continue;
0695             for (j = 0; itv->card->pci_list[j].device; j++) {
0696                 if (itv->pdev->device !=
0697                     itv->card->pci_list[j].device)
0698                     continue;
0699                 if (itv->pdev->subsystem_vendor !=
0700                     itv->card->pci_list[j].subsystem_vendor)
0701                     continue;
0702                 if (itv->pdev->subsystem_device !=
0703                     itv->card->pci_list[j].subsystem_device)
0704                     continue;
0705                 IVTV_INFO("Autodetected %s card (%s based)\n",
0706                         itv->card->name, chipname);
0707                 goto done;
0708             }
0709         }
0710     }
0711 done:
0712 
0713     if (itv->card == NULL) {
0714         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
0715         IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
0716              itv->pdev->vendor, itv->pdev->device);
0717         IVTV_ERR("              subsystem vendor/device: [%04x:%04x]\n",
0718              itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
0719         IVTV_ERR("              %s based\n", chipname);
0720         IVTV_ERR("Defaulting to %s card\n", itv->card->name);
0721         IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
0722         IVTV_ERR("card you have to the linux-media mailinglist (www.linuxtv.org)\n");
0723         IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
0724     }
0725     itv->v4l2_cap = itv->card->v4l2_capabilities;
0726     itv->card_name = itv->card->name;
0727     itv->card_i2c = itv->card->i2c;
0728 }
0729 
0730 /* Precondition: the ivtv structure has been memset to 0. Only
0731    the dev and num fields have been filled in.
0732    No assumptions on the card type may be made here (see ivtv_init_struct2
0733    for that).
0734  */
0735 static int ivtv_init_struct1(struct ivtv *itv)
0736 {
0737     itv->base_addr = pci_resource_start(itv->pdev, 0);
0738     itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
0739     itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
0740 
0741     mutex_init(&itv->serialize_lock);
0742     mutex_init(&itv->i2c_bus_lock);
0743     mutex_init(&itv->udma.lock);
0744 
0745     spin_lock_init(&itv->lock);
0746     spin_lock_init(&itv->dma_reg_lock);
0747 
0748     kthread_init_worker(&itv->irq_worker);
0749     itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
0750                        "%s", itv->v4l2_dev.name);
0751     if (IS_ERR(itv->irq_worker_task)) {
0752         IVTV_ERR("Could not create ivtv task\n");
0753         return -1;
0754     }
0755     /* must use the FIFO scheduler as it is realtime sensitive */
0756     sched_set_fifo(itv->irq_worker_task);
0757 
0758     kthread_init_work(&itv->irq_work, ivtv_irq_work_handler);
0759 
0760     /* Initial settings */
0761     itv->cxhdl.port = CX2341X_PORT_MEMORY;
0762     itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
0763     init_waitqueue_head(&itv->eos_waitq);
0764     init_waitqueue_head(&itv->event_waitq);
0765     init_waitqueue_head(&itv->vsync_waitq);
0766     init_waitqueue_head(&itv->dma_waitq);
0767     timer_setup(&itv->dma_timer, ivtv_unfinished_dma, 0);
0768 
0769     itv->cur_dma_stream = -1;
0770     itv->cur_pio_stream = -1;
0771 
0772     /* Ctrls */
0773     itv->speed = 1000;
0774 
0775     /* VBI */
0776     itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
0777     itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
0778 
0779     /* Init the sg table for osd/yuv output */
0780     sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
0781 
0782     /* OSD */
0783     itv->osd_global_alpha_state = 1;
0784     itv->osd_global_alpha = 255;
0785 
0786     /* YUV */
0787     atomic_set(&itv->yuv_info.next_dma_frame, -1);
0788     itv->yuv_info.lace_mode = ivtv_yuv_mode;
0789     itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
0790     itv->yuv_info.max_frames_buffered = 3;
0791     itv->yuv_info.track_osd = 1;
0792     return 0;
0793 }
0794 
0795 /* Second initialization part. Here the card type has been
0796    autodetected. */
0797 static void ivtv_init_struct2(struct ivtv *itv)
0798 {
0799     int i;
0800 
0801     for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
0802         if (itv->card->video_inputs[i].video_type == 0)
0803             break;
0804     itv->nof_inputs = i;
0805     for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
0806         if (itv->card->audio_inputs[i].audio_type == 0)
0807             break;
0808     itv->nof_audio_inputs = i;
0809 
0810     if (itv->card->hw_all & IVTV_HW_CX25840) {
0811         itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
0812     } else {
0813         itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
0814     }
0815 
0816     /* Find tuner input */
0817     for (i = 0; i < itv->nof_inputs; i++) {
0818         if (itv->card->video_inputs[i].video_type ==
0819                 IVTV_CARD_INPUT_VID_TUNER)
0820             break;
0821     }
0822     if (i >= itv->nof_inputs)
0823         i = 0;
0824     itv->active_input = i;
0825     itv->audio_input = itv->card->video_inputs[i].audio_index;
0826 }
0827 
0828 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
0829               const struct pci_device_id *pci_id)
0830 {
0831     u16 cmd;
0832     unsigned char pci_latency;
0833 
0834     IVTV_DEBUG_INFO("Enabling pci device\n");
0835 
0836     if (pci_enable_device(pdev)) {
0837         IVTV_ERR("Can't enable device!\n");
0838         return -EIO;
0839     }
0840     if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
0841         IVTV_ERR("No suitable DMA available.\n");
0842         return -EIO;
0843     }
0844     if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
0845         IVTV_ERR("Cannot request encoder memory region.\n");
0846         return -EIO;
0847     }
0848 
0849     if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
0850                 IVTV_REG_SIZE, "ivtv registers")) {
0851         IVTV_ERR("Cannot request register memory region.\n");
0852         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
0853         return -EIO;
0854     }
0855 
0856     if (itv->has_cx23415 &&
0857         !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
0858                 IVTV_DECODER_SIZE, "ivtv decoder")) {
0859         IVTV_ERR("Cannot request decoder memory region.\n");
0860         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
0861         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
0862         return -EIO;
0863     }
0864 
0865     /* Check for bus mastering */
0866     pci_read_config_word(pdev, PCI_COMMAND, &cmd);
0867     if (!(cmd & PCI_COMMAND_MASTER)) {
0868         IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
0869         pci_set_master(pdev);
0870         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
0871         if (!(cmd & PCI_COMMAND_MASTER)) {
0872             IVTV_ERR("Bus Mastering is not enabled\n");
0873             if (itv->has_cx23415)
0874                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
0875                            IVTV_DECODER_SIZE);
0876             release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
0877             release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
0878             return -ENXIO;
0879         }
0880     }
0881     IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
0882 
0883     pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
0884 
0885     if (pci_latency < 64 && ivtv_pci_latency) {
0886         IVTV_INFO("Unreasonably low latency timer, setting to 64 (was %d)\n",
0887               pci_latency);
0888         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
0889         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
0890     }
0891     /* This config space value relates to DMA latencies. The
0892        default value 0x8080 is too low however and will lead
0893        to DMA errors. 0xffff is the max value which solves
0894        these problems. */
0895     pci_write_config_dword(pdev, 0x40, 0xffff);
0896 
0897     IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, irq: %d, latency: %d, memory: 0x%llx\n",
0898            pdev->device, pdev->revision, pdev->bus->number,
0899            PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
0900            pdev->irq, pci_latency, (u64)itv->base_addr);
0901 
0902     return 0;
0903 }
0904 
0905 static void ivtv_load_and_init_modules(struct ivtv *itv)
0906 {
0907     u32 hw = itv->card->hw_all;
0908     unsigned i;
0909 
0910     /* check which i2c devices are actually found */
0911     for (i = 0; i < 32; i++) {
0912         u32 device = BIT(i);
0913 
0914         if (!(device & hw))
0915             continue;
0916         if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
0917             /* GPIO and TVEEPROM do not use i2c probing */
0918             itv->hw_flags |= device;
0919             continue;
0920         }
0921         if (ivtv_i2c_register(itv, i) == 0)
0922             itv->hw_flags |= device;
0923     }
0924 
0925     /* probe for legacy IR controllers that aren't in card definitions */
0926     if ((itv->hw_flags & IVTV_HW_IR_ANY) == 0)
0927         ivtv_i2c_new_ir_legacy(itv);
0928 
0929     if (itv->card->hw_all & IVTV_HW_CX25840)
0930         itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
0931     else if (itv->card->hw_all & IVTV_HW_SAA717X)
0932         itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
0933     else if (itv->card->hw_all & IVTV_HW_SAA7114)
0934         itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
0935     else
0936         itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
0937     itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
0938     itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
0939 
0940     hw = itv->hw_flags;
0941 
0942     if (itv->card->type == IVTV_CARD_CX23416GYC) {
0943         /* Several variations of this card exist, detect which card
0944            type should be used. */
0945         if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
0946             itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
0947         else if ((hw & IVTV_HW_UPD64031A) == 0)
0948             itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
0949     }
0950     else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
0951          itv->card->type == IVTV_CARD_GV_MVPRX2E) {
0952         /* The crystal frequency of GVMVPRX is 24.576MHz */
0953         v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
0954             SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
0955     }
0956 
0957     if (hw & IVTV_HW_CX25840) {
0958         itv->vbi.raw_decoder_line_size = 1444;
0959         itv->vbi.raw_decoder_sav_odd_field = 0x20;
0960         itv->vbi.raw_decoder_sav_even_field = 0x60;
0961         itv->vbi.sliced_decoder_line_size = 272;
0962         itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
0963         itv->vbi.sliced_decoder_sav_even_field = 0xF0;
0964     }
0965 
0966     if (hw & IVTV_HW_SAA711X) {
0967         /* determine the exact saa711x model */
0968         itv->hw_flags &= ~IVTV_HW_SAA711X;
0969 
0970         if (strstr(itv->sd_video->name, "saa7114")) {
0971             itv->hw_flags |= IVTV_HW_SAA7114;
0972             /* VBI is not yet supported by the saa7114 driver. */
0973             itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
0974         } else {
0975             itv->hw_flags |= IVTV_HW_SAA7115;
0976         }
0977         itv->vbi.raw_decoder_line_size = 1443;
0978         itv->vbi.raw_decoder_sav_odd_field = 0x25;
0979         itv->vbi.raw_decoder_sav_even_field = 0x62;
0980         itv->vbi.sliced_decoder_line_size = 51;
0981         itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
0982         itv->vbi.sliced_decoder_sav_even_field = 0xEC;
0983     }
0984 
0985     if (hw & IVTV_HW_SAA717X) {
0986         itv->vbi.raw_decoder_line_size = 1443;
0987         itv->vbi.raw_decoder_sav_odd_field = 0x25;
0988         itv->vbi.raw_decoder_sav_even_field = 0x62;
0989         itv->vbi.sliced_decoder_line_size = 51;
0990         itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
0991         itv->vbi.sliced_decoder_sav_even_field = 0xEC;
0992     }
0993 }
0994 
0995 static int ivtv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
0996 {
0997     int retval = 0;
0998     int vbi_buf_size;
0999     struct ivtv *itv;
1000 
1001     itv = kzalloc(sizeof(struct ivtv), GFP_KERNEL);
1002     if (itv == NULL)
1003         return -ENOMEM;
1004     itv->pdev = pdev;
1005     itv->instance = v4l2_device_set_name(&itv->v4l2_dev, "ivtv",
1006                         &ivtv_instance);
1007 
1008     retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
1009     if (retval) {
1010         kfree(itv);
1011         return retval;
1012     }
1013     IVTV_INFO("Initializing card %d\n", itv->instance);
1014 
1015     ivtv_process_options(itv);
1016     if (itv->options.cardtype == -1) {
1017         retval = -ENODEV;
1018         goto err;
1019     }
1020     if (ivtv_init_struct1(itv)) {
1021         retval = -ENOMEM;
1022         goto err;
1023     }
1024     retval = cx2341x_handler_init(&itv->cxhdl, 50);
1025     if (retval)
1026         goto err;
1027     itv->v4l2_dev.ctrl_handler = &itv->cxhdl.hdl;
1028     itv->cxhdl.ops = &ivtv_cxhdl_ops;
1029     itv->cxhdl.priv = itv;
1030     itv->cxhdl.func = ivtv_api_func;
1031 
1032     IVTV_DEBUG_INFO("base addr: 0x%llx\n", (u64)itv->base_addr);
1033 
1034     /* PCI Device Setup */
1035     retval = ivtv_setup_pci(itv, pdev, pci_id);
1036     if (retval == -EIO)
1037         goto free_worker;
1038     if (retval == -ENXIO)
1039         goto free_mem;
1040 
1041     /* map io memory */
1042     IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1043            (u64)itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1044     itv->enc_mem = ioremap(itv->base_addr + IVTV_ENCODER_OFFSET,
1045                        IVTV_ENCODER_SIZE);
1046     if (!itv->enc_mem) {
1047         IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 encoder memory\n");
1048         IVTV_ERR("Each capture card with a CX23415/6 needs 8 MB of vmalloc address space for this window\n");
1049         IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1050         IVTV_ERR("Use the vmalloc= kernel command line option to set VmallocTotal to a larger value\n");
1051         retval = -ENOMEM;
1052         goto free_mem;
1053     }
1054 
1055     if (itv->has_cx23415) {
1056         IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1057                 (u64)itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1058         itv->dec_mem = ioremap(itv->base_addr + IVTV_DECODER_OFFSET,
1059                 IVTV_DECODER_SIZE);
1060         if (!itv->dec_mem) {
1061             IVTV_ERR("ioremap failed. Can't get a window into CX23415 decoder memory\n");
1062             IVTV_ERR("Each capture card with a CX23415 needs 8 MB of vmalloc address space for this window\n");
1063             IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1064             IVTV_ERR("Use the vmalloc= kernel command line option to set VmallocTotal to a larger value\n");
1065             retval = -ENOMEM;
1066             goto free_mem;
1067         }
1068     }
1069     else {
1070         itv->dec_mem = itv->enc_mem;
1071     }
1072 
1073     /* map registers memory */
1074     IVTV_DEBUG_INFO("attempting ioremap at 0x%llx len 0x%08x\n",
1075            (u64)itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1076     itv->reg_mem =
1077         ioremap(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1078     if (!itv->reg_mem) {
1079         IVTV_ERR("ioremap failed. Can't get a window into CX23415/6 register space\n");
1080         IVTV_ERR("Each capture card with a CX23415/6 needs 64 kB of vmalloc address space for this window\n");
1081         IVTV_ERR("Check the output of 'grep Vmalloc /proc/meminfo'\n");
1082         IVTV_ERR("Use the vmalloc= kernel command line option to set VmallocTotal to a larger value\n");
1083         retval = -ENOMEM;
1084         goto free_io;
1085     }
1086 
1087     retval = ivtv_gpio_init(itv);
1088     if (retval)
1089         goto free_io;
1090 
1091     /* active i2c  */
1092     IVTV_DEBUG_INFO("activating i2c...\n");
1093     if (init_ivtv_i2c(itv)) {
1094         IVTV_ERR("Could not initialize i2c\n");
1095         goto free_io;
1096     }
1097 
1098     if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1099         /* Based on the model number the cardtype may be changed.
1100            The PCI IDs are not always reliable. */
1101         ivtv_process_eeprom(itv);
1102     }
1103     if (itv->card->comment)
1104         IVTV_INFO("%s", itv->card->comment);
1105     if (itv->card->v4l2_capabilities == 0) {
1106         /* card was detected but is not supported */
1107         retval = -ENODEV;
1108         goto free_i2c;
1109     }
1110 
1111     if (itv->std == 0) {
1112         itv->std = V4L2_STD_NTSC_M;
1113     }
1114 
1115     if (itv->options.tuner == -1) {
1116         int i;
1117 
1118         for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1119             if ((itv->std & itv->card->tuners[i].std) == 0)
1120                 continue;
1121             itv->options.tuner = itv->card->tuners[i].tuner;
1122             break;
1123         }
1124     }
1125     /* if no tuner was found, then pick the first tuner in the card list */
1126     if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1127         itv->std = itv->card->tuners[0].std;
1128         if (itv->std & V4L2_STD_PAL)
1129             itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1130         else if (itv->std & V4L2_STD_NTSC)
1131             itv->std = V4L2_STD_NTSC_M;
1132         else if (itv->std & V4L2_STD_SECAM)
1133             itv->std = V4L2_STD_SECAM_L;
1134         itv->options.tuner = itv->card->tuners[0].tuner;
1135     }
1136     if (itv->options.radio == -1)
1137         itv->options.radio = (itv->card->radio_input.audio_type != 0);
1138 
1139     /* The card is now fully identified, continue with card-specific
1140        initialization. */
1141     ivtv_init_struct2(itv);
1142 
1143     ivtv_load_and_init_modules(itv);
1144 
1145     if (itv->std & V4L2_STD_525_60) {
1146         itv->is_60hz = 1;
1147         itv->is_out_60hz = 1;
1148     } else {
1149         itv->is_50hz = 1;
1150         itv->is_out_50hz = 1;
1151     }
1152 
1153     itv->yuv_info.osd_full_w = 720;
1154     itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1155     itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1156     itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1157 
1158     cx2341x_handler_set_50hz(&itv->cxhdl, itv->is_50hz);
1159 
1160     itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1161     itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1162     itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1163     itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1164     itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1165 
1166     /* Setup VBI Raw Size. Should be big enough to hold PAL.
1167        It is possible to switch between PAL and NTSC, so we need to
1168        take the largest size here. */
1169     /* 1456 is multiple of 16, real size = 1444 */
1170     itv->vbi.raw_size = 1456;
1171     /* We use a buffer size of 1/2 of the total size needed for a
1172        frame. This is actually very useful, since we now receive
1173        a field at a time and that makes 'compressing' the raw data
1174        down to size by stripping off the SAV codes a lot easier.
1175        Note: having two different buffer sizes prevents standard
1176        switching on the fly. We need to find a better solution... */
1177     vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1178     itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1179     itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1180 
1181     if (itv->options.radio > 0)
1182         itv->v4l2_cap |= V4L2_CAP_RADIO;
1183 
1184     if (itv->options.tuner > -1) {
1185         struct tuner_setup setup;
1186 
1187         setup.addr = ADDR_UNSET;
1188         setup.type = itv->options.tuner;
1189         setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1190         if (itv->options.radio > 0)
1191             setup.mode_mask |= T_RADIO;
1192         setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1193             ivtv_reset_tuner_gpio : NULL;
1194         ivtv_call_all(itv, tuner, s_type_addr, &setup);
1195         if (setup.type == TUNER_XC2028) {
1196             static struct xc2028_ctrl ctrl = {
1197                 .fname = XC2028_DEFAULT_FIRMWARE,
1198                 .max_len = 64,
1199             };
1200             struct v4l2_priv_tun_config cfg = {
1201                 .tuner = itv->options.tuner,
1202                 .priv = &ctrl,
1203             };
1204             ivtv_call_all(itv, tuner, s_config, &cfg);
1205         }
1206     }
1207 
1208     /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1209        are not. */
1210     itv->tuner_std = itv->std;
1211 
1212     if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1213         struct v4l2_ctrl_handler *hdl = itv->v4l2_dev.ctrl_handler;
1214 
1215         itv->ctrl_pts = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1216                 V4L2_CID_MPEG_VIDEO_DEC_PTS, 0, 0, 0, 0);
1217         itv->ctrl_frame = v4l2_ctrl_new_std(hdl, &ivtv_hdl_out_ops,
1218                 V4L2_CID_MPEG_VIDEO_DEC_FRAME, 0, 0, 0, 0);
1219         /* Note: V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO is not supported,
1220            mask that menu item. */
1221         itv->ctrl_audio_playback =
1222             v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1223                 V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK,
1224                 V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1225                 1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1226                 V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREO);
1227         itv->ctrl_audio_multilingual_playback =
1228             v4l2_ctrl_new_std_menu(hdl, &ivtv_hdl_out_ops,
1229                 V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK,
1230                 V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO,
1231                 1 << V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO,
1232                 V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFT);
1233         if (hdl->error) {
1234             retval = hdl->error;
1235             goto free_i2c;
1236         }
1237         v4l2_ctrl_cluster(2, &itv->ctrl_pts);
1238         v4l2_ctrl_cluster(2, &itv->ctrl_audio_playback);
1239         ivtv_call_all(itv, video, s_std_output, itv->std);
1240         /* Turn off the output signal. The mpeg decoder is not yet
1241            active so without this you would get a green image until the
1242            mpeg decoder becomes active. */
1243         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1244     }
1245 
1246     /* clear interrupt mask, effectively disabling interrupts */
1247     ivtv_set_irq_mask(itv, 0xffffffff);
1248 
1249     /* Register IRQ */
1250     retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
1251          IRQF_SHARED, itv->v4l2_dev.name, (void *)itv);
1252     if (retval) {
1253         IVTV_ERR("Failed to register irq %d\n", retval);
1254         goto free_i2c;
1255     }
1256 
1257     retval = ivtv_streams_setup(itv);
1258     if (retval) {
1259         IVTV_ERR("Error %d setting up streams\n", retval);
1260         goto free_irq;
1261     }
1262     retval = ivtv_streams_register(itv);
1263     if (retval) {
1264         IVTV_ERR("Error %d registering devices\n", retval);
1265         goto free_streams;
1266     }
1267     IVTV_INFO("Initialized card: %s\n", itv->card_name);
1268 
1269     /* Load ivtv submodules (ivtv-alsa) */
1270     request_modules(itv);
1271     return 0;
1272 
1273 free_streams:
1274     ivtv_streams_cleanup(itv);
1275 free_irq:
1276     free_irq(itv->pdev->irq, (void *)itv);
1277 free_i2c:
1278     v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1279     exit_ivtv_i2c(itv);
1280 free_io:
1281     ivtv_iounmap(itv);
1282 free_mem:
1283     release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1284     release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1285     if (itv->has_cx23415)
1286         release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1287 free_worker:
1288     kthread_stop(itv->irq_worker_task);
1289 err:
1290     if (retval == 0)
1291         retval = -ENODEV;
1292     IVTV_ERR("Error %d on initialization\n", retval);
1293 
1294     v4l2_device_unregister(&itv->v4l2_dev);
1295     kfree(itv);
1296     return retval;
1297 }
1298 
1299 int ivtv_init_on_first_open(struct ivtv *itv)
1300 {
1301     struct v4l2_frequency vf;
1302     /* Needed to call ioctls later */
1303     struct ivtv_open_id fh;
1304     int fw_retry_count = 3;
1305     int video_input;
1306 
1307     fh.itv = itv;
1308     fh.type = IVTV_ENC_STREAM_TYPE_MPG;
1309 
1310     if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1311         return -ENXIO;
1312 
1313     if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1314         return 0;
1315 
1316     while (--fw_retry_count > 0) {
1317         /* load firmware */
1318         if (ivtv_firmware_init(itv) == 0)
1319             break;
1320         if (fw_retry_count > 1)
1321             IVTV_WARN("Retry loading firmware\n");
1322     }
1323 
1324     if (fw_retry_count == 0) {
1325         set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1326         return -ENXIO;
1327     }
1328 
1329     /* Try and get firmware versions */
1330     IVTV_DEBUG_INFO("Getting firmware version..\n");
1331     ivtv_firmware_versions(itv);
1332 
1333     if (itv->card->hw_all & IVTV_HW_CX25840)
1334         v4l2_subdev_call(itv->sd_video, core, load_fw);
1335 
1336     vf.tuner = 0;
1337     vf.type = V4L2_TUNER_ANALOG_TV;
1338     vf.frequency = 6400; /* the tuner 'baseline' frequency */
1339 
1340     /* Set initial frequency. For PAL/SECAM broadcasts no
1341        'default' channel exists AFAIK. */
1342     if (itv->std == V4L2_STD_NTSC_M_JP) {
1343         vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1344     }
1345     else if (itv->std & V4L2_STD_NTSC_M) {
1346         vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1347     }
1348 
1349     video_input = itv->active_input;
1350     itv->active_input++;    /* Force update of input */
1351     ivtv_s_input(NULL, &fh, video_input);
1352 
1353     /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1354        in one place. */
1355     itv->std++;     /* Force full standard initialization */
1356     itv->std_out = itv->std;
1357     ivtv_s_frequency(NULL, &fh, &vf);
1358 
1359     if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1360         /* Turn on the TV-out: ivtv_init_mpeg_decoder() initializes
1361            the mpeg decoder so now the saa7127 receives a proper
1362            signal. */
1363         ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 1);
1364         ivtv_init_mpeg_decoder(itv);
1365     }
1366 
1367     /* On a cx23416 this seems to be able to enable DMA to the chip? */
1368     if (!itv->has_cx23415)
1369         write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1370 
1371     ivtv_s_std_enc(itv, itv->tuner_std);
1372 
1373     /* Default interrupts enabled. For the PVR350 this includes the
1374        decoder VSYNC interrupt, which is always on. It is not only used
1375        during decoding but also by the OSD.
1376        Some old PVR250 cards had a cx23415, so testing for that is too
1377        general. Instead test if the card has video output capability. */
1378     if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1379         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1380         ivtv_set_osd_alpha(itv);
1381         ivtv_s_std_dec(itv, itv->tuner_std);
1382     } else {
1383         ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1384     }
1385 
1386     /* Setup initial controls */
1387     cx2341x_handler_setup(&itv->cxhdl);
1388     return 0;
1389 }
1390 
1391 static void ivtv_remove(struct pci_dev *pdev)
1392 {
1393     struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev);
1394     struct ivtv *itv = to_ivtv(v4l2_dev);
1395     int i;
1396 
1397     IVTV_DEBUG_INFO("Removing card\n");
1398 
1399     flush_request_modules(itv);
1400 
1401     if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1402         /* Stop all captures */
1403         IVTV_DEBUG_INFO("Stopping all streams\n");
1404         if (atomic_read(&itv->capturing) > 0)
1405             ivtv_stop_all_captures(itv);
1406 
1407         /* Stop all decoding */
1408         IVTV_DEBUG_INFO("Stopping decoding\n");
1409 
1410         /* Turn off the TV-out */
1411         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
1412             ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_stream, 0);
1413         if (atomic_read(&itv->decoding) > 0) {
1414             int type;
1415 
1416             if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1417                 type = IVTV_DEC_STREAM_TYPE_YUV;
1418             else
1419                 type = IVTV_DEC_STREAM_TYPE_MPG;
1420             ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1421                 V4L2_DEC_CMD_STOP_TO_BLACK | V4L2_DEC_CMD_STOP_IMMEDIATELY, 0);
1422         }
1423         ivtv_halt_firmware(itv);
1424     }
1425 
1426     /* Interrupts */
1427     ivtv_set_irq_mask(itv, 0xffffffff);
1428     del_timer_sync(&itv->dma_timer);
1429 
1430     /* Kill irq worker */
1431     kthread_flush_worker(&itv->irq_worker);
1432     kthread_stop(itv->irq_worker_task);
1433 
1434     ivtv_streams_cleanup(itv);
1435     ivtv_udma_free(itv);
1436 
1437     v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1438 
1439     exit_ivtv_i2c(itv);
1440 
1441     free_irq(itv->pdev->irq, (void *)itv);
1442     ivtv_iounmap(itv);
1443 
1444     release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1445     release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1446     if (itv->has_cx23415)
1447         release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1448 
1449     pci_disable_device(itv->pdev);
1450     for (i = 0; i < IVTV_VBI_FRAMES; i++)
1451         kfree(itv->vbi.sliced_mpeg_data[i]);
1452 
1453     pr_info("Removed %s\n", itv->card_name);
1454 
1455     v4l2_device_unregister(&itv->v4l2_dev);
1456     kfree(itv);
1457 }
1458 
1459 /* define a pci_driver for card detection */
1460 static struct pci_driver ivtv_pci_driver = {
1461       .name =     "ivtv",
1462       .id_table = ivtv_pci_tbl,
1463       .probe =    ivtv_probe,
1464       .remove =   ivtv_remove,
1465 };
1466 
1467 static int __init module_start(void)
1468 {
1469     pr_info("Start initialization, version %s\n", IVTV_VERSION);
1470 
1471     /* Validate parameters */
1472     if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1473         pr_err("Exiting, ivtv_first_minor must be between 0 and %d\n",
1474              IVTV_MAX_CARDS - 1);
1475         return -1;
1476     }
1477 
1478     if (ivtv_debug < 0 || ivtv_debug > 2047) {
1479         ivtv_debug = 0;
1480         pr_info("Debug value must be >= 0 and <= 2047\n");
1481     }
1482 
1483     if (pci_register_driver(&ivtv_pci_driver)) {
1484         pr_err("Error detecting PCI card\n");
1485         return -ENODEV;
1486     }
1487     pr_info("End initialization\n");
1488     return 0;
1489 }
1490 
1491 static void __exit module_cleanup(void)
1492 {
1493     pci_unregister_driver(&ivtv_pci_driver);
1494 }
1495 
1496 /* Note: These symbols are exported because they are used by the ivtvfb
1497    framebuffer module and an infrared module for the IR-blaster. */
1498 EXPORT_SYMBOL(ivtv_set_irq_mask);
1499 EXPORT_SYMBOL(ivtv_api);
1500 EXPORT_SYMBOL(ivtv_vapi);
1501 EXPORT_SYMBOL(ivtv_vapi_result);
1502 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1503 EXPORT_SYMBOL(ivtv_debug);
1504 #ifdef CONFIG_VIDEO_ADV_DEBUG
1505 EXPORT_SYMBOL(ivtv_fw_debug);
1506 #endif
1507 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1508 EXPORT_SYMBOL(ivtv_udma_setup);
1509 EXPORT_SYMBOL(ivtv_udma_unmap);
1510 EXPORT_SYMBOL(ivtv_udma_alloc);
1511 EXPORT_SYMBOL(ivtv_udma_prepare);
1512 EXPORT_SYMBOL(ivtv_init_on_first_open);
1513 EXPORT_SYMBOL(ivtv_firmware_check);
1514 
1515 module_init(module_start);
1516 module_exit(module_cleanup);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!