linux/drivers/media/pci/ivtv/ivtv-driver.c
<<
>>
Prefs
   1/*
   2    ivtv driver initialization and card probing
   3    Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4    Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5    Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20 */
  21
  22/* Main Driver file for the ivtv project:
  23 * Driver for the Conexant CX23415/CX23416 chip.
  24 * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  25 * License: GPL
  26 *
  27 * -----
  28 * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  29 *                      and Takeru KOMORIYA<komoriya@paken.org>
  30 *
  31 * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  32 *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  33 *
  34 * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
  35 *                using information from T.Adachi,Takeru KOMORIYA and others :-)
  36 *
  37 * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
  38 *                version by T.Adachi. Special thanks  Mr.Suzuki
  39 */
  40
  41#include "ivtv-driver.h"
  42#include "ivtv-version.h"
  43#include "ivtv-fileops.h"
  44#include "ivtv-i2c.h"
  45#include "ivtv-firmware.h"
  46#include "ivtv-queue.h"
  47#include "ivtv-udma.h"
  48#include "ivtv-irq.h"
  49#include "ivtv-mailbox.h"
  50#include "ivtv-streams.h"
  51#include "ivtv-ioctl.h"
  52#include "ivtv-cards.h"
  53#include "ivtv-vbi.h"
  54#include "ivtv-routing.h"
  55#include "ivtv-controls.h"
  56#include "ivtv-gpio.h"
  57#include <linux/dma-mapping.h>
  58#include <media/tveeprom.h>
  59#include <media/i2c/saa7115.h>
  60#include "tuner-xc2028.h"
  61#include <uapi/linux/sched/types.h>
  62
  63/* If you have already X v4l cards, then set this to X. This way
  64   the device numbers stay matched. Example: you have a WinTV card
  65   without radio and a PVR-350 with. Normally this would give a
  66   video1 device together with a radio0 device for the PVR. By
  67   setting this to 1 you ensure that radio0 is now also radio1. */
  68int ivtv_first_minor;
  69
  70/* Callback for registering extensions */
  71int (*ivtv_ext_init)(struct ivtv *);
  72EXPORT_SYMBOL(ivtv_ext_init);
  73
  74/* add your revision and whatnot here */
  75static const struct pci_device_id ivtv_pci_tbl[] = {
  76        {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
  77         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  78        {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
  79         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  80        {0,}
  81};
  82
  83MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
  84
  85/* ivtv instance counter */
  86static atomic_t ivtv_instance = ATOMIC_INIT(0);
  87
  88/* Parameter declarations */
  89static int cardtype[IVTV_MAX_CARDS];
  90static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  91                                     -1, -1, -1, -1, -1, -1, -1, -1,
  92                                     -1, -1, -1, -1, -1, -1, -1, -1,
  93                                     -1, -1, -1, -1, -1, -1, -1, -1 };
  94static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  95                                     -1, -1, -1, -1, -1, -1, -1, -1,
  96                                     -1, -1, -1, -1, -1, -1, -1, -1,
  97                                     -1, -1, -1, -1, -1, -1, -1, -1 };
  98static int i2c_clock_period[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  99                                               -1, -1, -1, -1, -1, -1, -1, -1,
 100                                               -1, -1, -1, -1, -1, -1, -1, -1,
 101                                               -1, -1, -1, -1, -1, -1, -1, -1 };
 102
 103static unsigned int cardtype_c = 1;
 104static unsigned int tuner_c = 1;
 105static int radio_c = 1;
 106static unsigned int i2c_clock_period_c = 1;
 107static char pal[] = "---";
 108static char secam[] = "--";
 109static char ntsc[] = "-";
 110
 111/* Buffers */
 112
 113/* DMA Buffers, Default size in MB allocated */
 114#define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
 115#define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
 116#define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
 117/* Exception: size in kB for this stream (MB is overkill) */
 118#define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
 119#define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
 120#define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
 121/* Exception: size in kB for this stream (MB is way overkill) */
 122#define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
 123
 124static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
 125static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
 126static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
 127static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
 128static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
 129static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
 130static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
 131
 132static int ivtv_yuv_mode;
 133static int ivtv_yuv_threshold = -1;
 134static int ivtv_pci_latency = 1;
 135
 136int ivtv_debug;
 137#ifdef CONFIG_VIDEO_ADV_DEBUG
 138int ivtv_fw_debug;
 139#endif
 140
 141static int tunertype = -1;
 142static int newi2c = -1;
 143
 144module_param_array(tuner, int, &tuner_c, 0644);
 145module_param_array(radio, int, &radio_c, 0644);
 146module_param_array(cardtype, int, &cardtype_c, 0644);
 147module_param_string(pal, pal, sizeof(pal), 0644);
 148module_param_string(secam, secam, sizeof(secam), 0644);
 149module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 150module_param_named(debug,ivtv_debug, int, 0644);
 151#ifdef CONFIG_VIDEO_ADV_DEBUG
 152module_param_named(fw_debug, ivtv_fw_debug, int, 0644);
 153#endif
 154module_param(ivtv_pci_latency, int, 0644);
 155module_param(ivtv_yuv_mode, int, 0644);
 156module_param(ivtv_yuv_threshold, int, 0644);
 157module_param(ivtv_first_minor, int, 0644);
 158
 159module_param(enc_mpg_buffers, int, 0644);
 160module_param(enc_yuv_buffers, int, 0644);
 161module_param(enc_vbi_buffers, int, 0644);
 162module_param(enc_pcm_buffers, int, 0644);
 163module_param(dec_mpg_buffers, int, 0644);
 164module_param(dec_yuv_buffers, int, 0644);
 165module_param(dec_vbi_buffers, int, 0644);
 166
 167module_param(tunertype, int, 0644);
 168module_param(newi2c, int, 0644);
 169module_param_array(i2c_clock_period, int, &i2c_clock_period_c, 0644);
 170
 171MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
 172                        "\t\t\tsee tuner.h for values");
 173MODULE_PARM_DESC(radio,
 174                 "Enable or disable the radio. Use only if autodetection\n"
 175                 "\t\t\tfails. 0 = disable, 1 = enable");
 176MODULE_PARM_DESC(cardtype,
 177                 "Only use this option if your card is not detected properly.\n"
 178                 "\t\tSpecify card type:\n"
 179                 "\t\t\t 1 = WinTV PVR 250\n"
 180                 "\t\t\t 2 = WinTV PVR 350\n"
 181                 "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
 182                 "\t\t\t 4 = AVerMedia M179\n"
 183                 "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
 184                 "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
 185                 "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
 186                 "\t\t\t 8 = Adaptec AVC-2410\n"
 187                 "\t\t\t 9 = Adaptec AVC-2010\n"
 188                 "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
 189                 "\t\t\t11 = AOpen VA2000MAX-STN6\n"
 190                 "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
 191                 "\t\t\t13 = I/O Data GV-MVP/RX\n"
 192                 "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
 193                 "\t\t\t15 = GOTVIEW PCI DVD\n"
 194                 "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
 195                 "\t\t\t17 = Yuan MPC622\n"
 196                 "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
 197                 "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
 198                 "\t\t\t20 = Club3D ZAP-TV1x01\n"
 199                 "\t\t\t21 = AverTV MCE 116 Plus\n"
 200                 "\t\t\t22 = ASUS Falcon2\n"
 201                 "\t\t\t23 = AverMedia PVR-150 Plus\n"
 202                 "\t\t\t24 = AverMedia EZMaker PCI Deluxe\n"
 203                 "\t\t\t25 = AverMedia M104 (not yet working)\n"
 204                 "\t\t\t26 = Buffalo PC-MV5L/PCI\n"
 205                 "\t\t\t27 = AVerMedia UltraTV 1500 MCE\n"
 206                 "\t\t\t28 = Sony VAIO Giga Pocket (ENX Kikyou)\n"
 207                 "\t\t\t 0 = Autodetect (default)\n"
 208                 "\t\t\t-1 = Ignore this card\n\t\t");
 209MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
 210MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
 211MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
 212MODULE_PARM_DESC(tunertype,
 213                "Specify tuner type:\n"
 214                "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
 215                "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
 216                "\t\t\t-1 = Autodetect (default)\n");
 217MODULE_PARM_DESC(debug,
 218                 "Debug level (bitmask). Default: 0\n"
 219                 "\t\t\t   1/0x0001: warning\n"
 220                 "\t\t\t   2/0x0002: info\n"
 221                 "\t\t\t   4/0x0004: mailbox\n"
 222                 "\t\t\t   8/0x0008: ioctl\n"
 223                 "\t\t\t  16/0x0010: file\n"
 224                 "\t\t\t  32/0x0020: dma\n"
 225                 "\t\t\t  64/0x0040: irq\n"
 226                 "\t\t\t 128/0x0080: decoder\n"
 227                 "\t\t\t 256/0x0100: yuv\n"
 228                 "\t\t\t 512/0x0200: i2c\n"
 229                 "\t\t\t1024/0x0400: high volume\n");
 230#ifdef CONFIG_VIDEO_ADV_DEBUG
 231MODULE_PARM_DESC(fw_debug,
 232                 "Enable code for debugging firmware problems.  Default: 0\n");
 233#endif
 234MODULE_PARM_DESC(ivtv_pci_latency,
 235                 "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 236                 "\t\t\tDefault: Yes");
 237MODULE_PARM_DESC(ivtv_yuv_mode,
 238                 "Specify the yuv playback mode:\n"
 239                 "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
 240                 "\t\t\tDefault: 0 (interlaced)");
 241MODULE_PARM_DESC(ivtv_yuv_threshold,
 242                 "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
 243                 "\t\t\tDefault: 480");
 244MODULE_PARM_DESC(enc_mpg_buffers,
 245                 "Encoder MPG Buffers (in MB)\n"
 246                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
 247MODULE_PARM_DESC(enc_yuv_buffers,
 248                 "Encoder YUV Buffers (in MB)\n"
 249                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
 250MODULE_PARM_DESC(enc_vbi_buffers,
 251                 "Encoder VBI Buffers (in MB)\n"
 252                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
 253MODULE_PARM_DESC(enc_pcm_buffers,
 254                 "Encoder PCM buffers (in kB)\n"
 255                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
 256MODULE_PARM_DESC(dec_mpg_buffers,
 257                 "Decoder MPG buffers (in MB)\n"
 258                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
 259MODULE_PARM_DESC(dec_yuv_buffers,
 260                 "Decoder YUV buffers (in MB)\n"
 261                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
 262MODULE_PARM_DESC(dec_vbi_buffers,
 263                 "Decoder VBI buffers (in kB)\n"
 264                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
 265MODULE_PARM_DESC(newi2c,
 266                 "Use new I2C implementation\n"
 267                 "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
 268                 "\t\t\tDefault is autodetect");
 269MODULE_PARM_DESC(i2c_clock_period,
 270                 "Period of SCL for the I2C bus controlled by the CX23415/6\n"
 271                 "\t\t\tMin: 10 usec (100 kHz), Max: 4500 usec (222 Hz)\n"
 272                 "\t\t\tDefault: " __stringify(IVTV_DEFAULT_I2C_CLOCK_PERIOD));
 273
 274MODULE_PARM_DESC(ivtv_first_minor, "Set device node number assigned to first card");
 275
 276MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 277MODULE_DESCRIPTION("CX23415/CX23416 driver");
 278MODULE_LICENSE("GPL");
 279
 280MODULE_VERSION(IVTV_VERSION);
 281
 282#if defined(CONFIG_MODULES) && defined(MODULE)
 283static void request_module_async(struct work_struct *work)
 284{
 285        struct ivtv *dev = container_of(work, struct ivtv, request_module_wk);
 286
 287        /* Make sure ivtv-alsa module is loaded */
 288        request_module("ivtv-alsa");
 289
 290        /* Initialize ivtv-alsa for this instance of the cx18 device */
 291        if (ivtv_ext_init != NULL)
 292                ivtv_ext_init(dev);
 293}
 294
 295static void request_modules(struct ivtv *dev)
 296{
 297        INIT_WORK(&dev->request_module_wk, request_module_async);
 298        schedule_work(&dev->request_module_wk);
 299}
 300
 301static void flush_request_modules(struct ivtv *dev)
 302{
 303        flush_work(&dev->request_module_wk);
 304}
 305#else
 306#define request_modules(dev)
 307#define flush_request_modules(dev)
 308#endif /* CONFIG_MODULES */
 309
 310void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
 311{
 312        itv->irqmask &= ~mask;
 313        write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 314}
 315
 316void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
 317{
 318        itv->irqmask |= mask;
 319        write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 320}
 321
 322int ivtv_set_output_mode(struct ivtv *itv, int mode)
 323{
 324    int old_mode;
 325
 326    spin_lock(&itv->lock);
 327    old_mode = itv->output_mode;
 328    if (old_mode == 0)
 329        itv->output_mode = old_mode = mode;
 330    spin_unlock(&itv->lock);
 331    return old_mode;
 332}
 333
 334struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
 335{
 336        switch (itv->output_mode) {
 337        case OUT_MPG:
 338                return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 339        case OUT_YUV:
 340                return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 341        default:
 342                return NULL;
 343        }
 344}
 345
 346int ivtv_waitq(wait_queue_head_t *waitq)
 347{
 348        DEFINE_WAIT(wait);
 349
 350        prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
 351        schedule();
 352        finish_wait(waitq, &wait);
 353        return signal_pending(current) ? -EINTR : 0;
 354}
 355
 356/* Generic utility functions */
 357int ivtv_msleep_timeout(unsigned int msecs, int intr)
 358{
 359        int timeout = msecs_to_jiffies(msecs);
 360
 361        do {
 362                set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 363                timeout = schedule_timeout(timeout);
 364                if (intr) {
 365                        int ret = signal_pending(current);
 366
 367                        if (ret)
 368                                return ret;
 369                }
 370        } while (timeout);
 371        return 0;
 372}
 373
 374/* Release ioremapped memory */
 375static void ivtv_iounmap(struct ivtv *itv)
 376{
 377        if (itv == NULL)
 378                return;
 379
 380        /* Release registers memory */
 381        if (itv->reg_mem != NULL) {
 382                IVTV_DEBUG_INFO("releasing reg_mem\n");
 383                iounmap(itv->reg_mem);
 384                itv->reg_mem = NULL;
 385        }
 386        /* Release io memory */
 387        if (itv->has_cx23415 && itv->dec_mem != NULL) {
 388                IVTV_DEBUG_INFO("releasing dec_mem\n");
 389                iounmap(itv->dec_mem);
 390        }
 391        itv->dec_mem = NULL;
 392
 393        /* Release io memory */
 394        if (itv->enc_mem != NULL) {
 395                IVTV_DEBUG_INFO("releasing enc_mem\n");
 396                iounmap(itv->enc_mem);
 397                itv->enc_mem = NULL;
 398        }
 399}
 400
 401/* Hauppauge card? get values from tveeprom */
 402void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
 403{
 404        u8 eedata[256];
 405
 406        itv->i2c_client.addr = 0xA0 >> 1;
 407        tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
 408        tveeprom_hauppauge_analog(tv, eedata);
 409}
 410
 411static void ivtv_process_eeprom(struct ivtv *itv)
 412{
 413        struct tveeprom tv;
 414        int pci_slot = PCI_SLOT(itv->pdev->devfn);
 415
 416        ivtv_read_eeprom(itv, &tv);
 417
 418        /* Many thanks to Steven Toth from Hauppauge for providing the
 419           model numbers */
 420        switch (tv.model) {
 421                /* In a few cases the PCI subsystem IDs do not correctly
 422                   identify the card. A better method is to check the
 423                   model number from the eeprom instead. */
 424                case 30012 ... 30039:  /* Low profile PVR250 */
 425                case 32000 ... 32999:
 426                case 48000 ... 48099:  /* 48??? range are PVR250s with a cx23415 */
 427                case 48400 ... 48599:
 428                        itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
 429                        break;
 430                case 48100 ... 48399:
 431                case 48600 ... 48999:
 432                        itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
 433                        break;
 434                case 23000 ... 23999:  /* PVR500 */
 435                case 25000 ... 25999:  /* Low profile PVR150 */
 436                case 26000 ... 26999:  /* Regular PVR150 */
 437                        itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 438                        break;
 439                case 0:
 440                        IVTV_ERR("Invalid EEPROM\n");
 441                        return;
 442                default:
 443                        IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
 444                        itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 445                        break;
 446        }
 447
 448        switch (tv.model) {
 449                /* Old style PVR350 (with an saa7114) uses this input for
 450                   the tuner. */
 451                case 48254:
 452                        itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
 453                        break;
 454                default:
 455                        break;
 456        }
 457
 458        itv->v4l2_cap = itv->card->v4l2_capabilities;
 459        itv->card_name = itv->card->name;
 460        itv->card_i2c = itv->card->i2c;
 461
 462        /* If this is a PVR500 then it should be possible to detect whether it is the
 463           first or second unit by looking at the subsystem device ID: is bit 4 is
 464           set, then it is the second unit (according to info from Hauppauge).
 465
 466           However, while this works for most cards, I have seen a few PVR500 cards
 467           where both units have the same subsystem ID.
 468
 469           So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
 470           PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
 471           it is the second unit. It is possible that it is a different slot when ivtv is
 472           used in Xen, in that case I ignore this card here. The worst that can happen
 473           is that the card presents itself with a non-working radio device.
 474
 475           This detection is needed since the eeprom reports incorrectly that a radio is
 476           present on the second unit. */
 477        if (tv.model / 1000 == 23) {
 478                static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
 479                        .radio = { 0x60, I2C_CLIENT_END },
 480                        .demod = { 0x43, I2C_CLIENT_END },
 481                        .tv = { 0x61, I2C_CLIENT_END },
 482                };
 483
 484                itv->card_name = "WinTV PVR 500";
 485                itv->card_i2c = &ivtv_i2c_radio;
 486                if (pci_slot == 8 || pci_slot == 9) {
 487                        int is_first = (pci_slot & 1) == 0;
 488
 489                        itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
 490                                                    "WinTV PVR 500 (unit #2)";
 491                        if (!is_first) {
 492                                IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
 493                                tv.has_radio = 0;
 494                        }
 495                }
 496        }
 497        IVTV_INFO("Autodetected %s\n", itv->card_name);
 498
 499        switch (tv.tuner_hauppauge_model) {
 500                case 85:
 501                case 99:
 502                case 112:
 503                        itv->pvr150_workaround = 1;
 504                        break;
 505                default:
 506                        break;
 507        }
 508        if (tv.tuner_type == TUNER_ABSENT)
 509                IVTV_ERR("tveeprom cannot autodetect tuner!\n");
 510
 511        if (itv->options.tuner == -1)
 512                itv->options.tuner = tv.tuner_type;
 513        if (itv->options.radio == -1)
 514                itv->options.radio = (tv.has_radio != 0);
 515        /* only enable newi2c if an IR blaster is present */
 516        if (itv->options.newi2c == -1 && tv.has_ir) {
 517                itv->options.newi2c = (tv.has_ir & 4) ? 1 : 0;
 518                if (itv->options.newi2c) {
 519                    IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
 520                    exit_ivtv_i2c(itv);
 521                    init_ivtv_i2c(itv);
 522                }
 523        }
 524
 525        if (itv->std != 0)
 526                /* user specified tuner standard */
 527                return;
 528
 529        /* autodetect tuner standard */
 530        if (tv.tuner_formats & V4L2_STD_PAL) {
 531                IVTV_DEBUG_INFO("PAL tuner detected\n");
 532                itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 533        } else if (tv.tuner_formats & V4L2_STD_NTSC) {
 534                IVTV_DEBUG_INFO("NTSC tuner detected\n");
 535                itv->std |= V4L2_STD_NTSC_M;
 536        } else if (tv.tuner_formats & V4L2_STD_SECAM) {
 537                IVTV_DEBUG_INFO("SECAM tuner detected\n");
 538                itv->std |= V4L2_STD_SECAM_L;
 539        } else {
 540                IVTV_INFO("No tuner detected, default to NTSC-M\n");
 541                itv->std |= V4L2_STD_NTSC_M;
 542        }
 543}
 544
 545static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
 546{
 547        switch (pal[0]) {
 548                case '6':
 549                        tunertype = 0;
 550                        return V4L2_STD_PAL_60;
 551                case 'b':
 552                case 'B':
 553                case 'g':
 554                case 'G':
 555                case 'h':
 556                case 'H':
 557                        tunertype = 0;
 558                        return V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 559                case 'n':
 560                case 'N':
 561                        tunertype = 1;
 562                        if (pal[1] == 'c' || pal[1] == 'C')
 563                                return V4L2_STD_PAL_Nc;
 564                        return V4L2_STD_PAL_N;
 565                case 'i':
 566                case 'I':
 567                        tunertype = 0;
 568                        return V4L2_STD_PAL_I;
 569                case 'd':
 570                case 'D':
 571                case 'k':
 572                case 'K':
 573                        tunertype = 0;
 574                        return V4L2_STD_PAL_DK;
 575                case 'M':
 576                case 'm':
 577                        tunertype = 1;
 578                        return V4L2_STD_PAL_M;
 579                case '-':
 580                        break;
 581                default:
 582                        IVTV_WARN("pal= argument not recognised\n");
 583                        return 0;
 584        }
 585
 586        switch (secam[0]) {
 587                case 'b':
 588                case 'B':
 589                case 'g':
 590                case 'G':
 591                case 'h':
 592                case 'H':
 593                        tunertype = 0;
 594                        return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 595                case 'd':
 596                case 'D':
 597                case 'k':
 598                case 'K':
 599                        tunertype = 0;
 600                        return V4L2_STD_SECAM_DK;
 601                case 'l':
 602                case 'L':
 603                        tunertype = 0;
 604                        if (secam[1] == 'C' || secam[1] == 'c')
 605                                return V4L2_STD_SECAM_LC;
 606                        return V4L2_STD_SECAM_L;
 607                case '-':
 608                        break;
 609                default:
 610                        IVTV_WARN("secam= argument not recognised\n");
 611                        return 0;
 612        }
 613
 614        switch (ntsc[0]) {
 615                case 'm':
 616                case 'M':
 617                        tunertype = 1;
 618                        return V4L2_STD_NTSC_M;
 619                case 'j':
 620                case 'J':
 621                        tunertype = 1;
 622                        return V4L2_STD_NTSC_M_JP;
 623                case 'k':
 624                case 'K':
 625                        tunertype = 1;
 626                        return V4L2_STD_NTSC_M_KR;
 627                case '-':
 628                        break;
 629                default:
 630                        IVTV_WARN("ntsc= argument not recognised\n");
 631                        return 0;
 632        }
 633
 634        /* no match found */
 635        return 0;
 636}
 637
 638static void ivtv_process_options(struct ivtv *itv)
 639{
 640        const char *chipname;
 641        int i, j;
 642
 643        itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
 644        itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
 645        itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
 646        itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
 647        itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
 648        itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
 649        itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
 650        itv->options.cardtype = cardtype[itv->instance];
 651        itv->options.tuner = tuner[itv->instance];
 652        itv->options.radio = radio[itv->instance];
 653
 654        itv->options.i2c_clock_period = i2c_clock_period[itv->instance];
 655        if (itv->options.i2c_clock_period == -1)
 656                itv->options.i2c_clock_period = IVTV_DEFAULT_I2C_CLOCK_PERIOD;
 657        else if (itv->options.i2c_clock_period < 10)
 658                itv->options.i2c_clock_period = 10;
 659        else if (itv->options.i2c_clock_period > 4500)
 660                itv->options.i2c_clock_period = 4500;
 661
 662        itv->options.newi2c = newi2c;
 663        if (tunertype < -1 || tunertype > 1) {
 664                IVTV_WARN("Invalid tunertype argument, will autodetect instead\n");
 665                tunertype = -1;
 666        }
 667        itv->std = ivtv_parse_std(itv);
 668        if (itv->std == 0 && tunertype >= 0)
 669                itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
 670        itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
 671        chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
 672        if (itv->options.cardtype == -1) {
 673                IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
 674                return;
 675        }
 676        if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
 677                IVTV_INFO("User specified %s card (detected %s based chip)\n",
 678                                itv->card->name, chipname);
 679        } else if (itv->options.cardtype != 0) {
 680                IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
 681        }
 682        if (itv->card == NULL) {
 683                if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
 684                    itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
 685                    itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
 686                        itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
 687                        IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
 688                                        chipname);
 689                }
 690        }
 691        if (itv->card == NULL) {
 692                for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
 693                        if (itv->card->pci_list == NULL)
 694                                continue;
 695                        for (j = 0; itv->card->pci_list[j].device; j++) {
 696                                if (itv->pdev->device !=
 697                                    itv->card->pci_list[j].device)
 698                                        continue;
 699                                if (itv->pdev->subsystem_vendor !=
 700                                    itv->card->pci_list[j].subsystem_vendor)
 701                                        continue;
 702                                if (itv->pdev->subsystem_device !=
 703                                    itv->card->pci_list[j].subsystem_device)
 704                                        continue;
 705                                IVTV_INFO("Autodetected %s card (%s based)\n",
 706                                                itv->card->name, chipname);
 707                                goto done;
 708                        }
 709                }
 710        }
 711done:
 712
 713        if (itv->card == NULL) {
 714                itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 715                IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
 716                     itv->pdev->vendor, itv->pdev->device);
 717                IVTV_ERR("              subsystem vendor/device: [%04x:%04x]\n",
 718                     itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
 719                IVTV_ERR("              %s based\n", chipname);
 720                IVTV_ERR("Defaulting to %s card\n", itv->card->name);
 721                IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 722                IVTV_ERR("card you have to the linux-media mailinglist (www.linuxtv.org)\n");
 723                IVTV_ERR("Prefix your subject line with [UNKNOWN IVTV CARD].\n");
 724        }
 725        itv->v4l2_cap = itv->card->v4l2_capabilities;
 726        itv->card_name = itv->card->name;
 727        itv->card_i2c = itv->card->i2c;
 728}
 729
 730/* Precondition: the ivtv structure has been memset to 0. Only
 731   the dev and num fields have been filled in.
 732   No assumptions on the card type may be made here (see ivtv_init_struct2
 733   for that).
 734 */
 735static int ivtv_init_struct1(struct ivtv *itv)
 736{
 737        itv->base_addr = pci_resource_start(itv->pdev, 0);
 738        itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
 739        itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
 740
 741        mutex_init(&itv->serialize_lock);
 742        mutex_init(&itv->i2c_bus_lock);
 743        mutex_init(&itv->udma.lock);
 744
 745        spin_lock_init(&itv->lock);
 746        spin_lock_init(&itv->dma_reg_lock);
 747
 748        kthread_init_worker(&itv->irq_worker);
 749        itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
 750                                           "%s", itv->v4l2_dev.name);
 751        if (IS_ERR(itv->irq_worker_task)) {
 752                IVTV_ERR("Could not create ivtv task\n");
 753                return -1;
 754        }
 755        /* must use the FIFO scheduler as it is realtime sensitive */
 756        sched_set_fifo(itv->irq_worker_task);
 757
 758        kthread_init_work(&itv->irq_work, ivtv_irq_work_handler);
 759
 760        /* Initial settings */
 761        itv->cxhdl.port = CX2341X_PORT_MEMORY;
 762        itv->cxhdl.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
 763        init_waitqueue_head(&itv->eos_waitq);
 764        init_waitqueue_head(&itv->event_waitq);
 765        init_waitqueue_head(&itv->vsync_waitq);
 766        init_waitqueue_head(&itv->dma_waitq);
 767        timer_setup(&itv->dma_timer, ivtv_unfinished_dma, 0);
 768
 769        itv->cur_dma_stream = -1;
 770        itv->cur_pio_stream = -1;
 771
 772        /* Ctrls */
 773        itv->speed = 1000;
 774
 775        /* VBI */
 776        itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 777        itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 778
 779        /* Init the sg table for osd/yuv output */
 780        sg_init_table(itv->udma.SGlist, IVTV_DMA_SG_OSD_ENT);
 781
 782        /* OSD */
 783        itv->osd_global_alpha_state = 1;
 784        itv->osd_global_alpha = 255;
 785
 786        /* YUV */
 787        atomic_set(&itv->yuv_info.next_dma_frame, -1);
 788        itv->yuv_info.lace_mode = ivtv_yuv_mode;
 789        itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 790        itv->yuv_info.max_frames_buffered = 3;
 791        itv->yuv_info.track_osd = 1;
 792        return 0;
 793}
 794
 795/* Second initialization part. Here the card type has been
 796   autodetected. */
 797static void ivtv_init_struct2(struct ivtv *itv)
 798{
 799        int i;
 800
 801        for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 802                if (itv->card->video_inputs[i].video_type == 0)
 803                        break;
 804        itv->nof_inputs = i;
 805        for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 806                if (itv->card->audio_inputs[i].audio_type == 0)
 807                        break;
 808        itv->nof_audio_inputs = i;
 809
 810        if (itv->card->hw_all & IVTV_HW_CX25840) {
 811                itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 812        } else {
 813                itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 814        }
 815
 816        /* Find tuner input */
 817        for (i = 0; i < itv->nof_inputs; i++) {
 818                if (itv->card->video_inputs[i].video_type ==
 819                                IVTV_CARD_INPUT_VID_TUNER)
 820                        break;
 821        }
 822        if (i >= itv->nof_inputs)
 823                i = 0;
 824        itv->active_input = i;
 825        itv->audio_input = itv->card->video_inputs[i].audio_index;
 826}
 827
 828static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
 829                          const struct pci_device_id *pci_id)
 830{
 831        u16 cmd;
 832        unsigned char pci_latency;
 833
 834        IVTV_DEBUG_INFO("Enabling pci device\n");
 835
 836        if (pci_enable_device(pdev)) {
 837                IVTV_ERR("Can't enable device!\n");
 838                return -EIO;
 839        }
 840        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
 841                IVTV_ERR("No suitable DMA available.\n");
 842                return -EIO;
 843        }
 844        if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 845                IVTV_ERR("Cannot request encoder memory region.\n");
 846                return -EIO;
 847        }
 848
 849        if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 850                                IVTV_REG_SIZE, "ivtv registers")) {
 851                IVTV_ERR("Cannot request register memory region.\n");
 852                release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 853                return -EIO;
 854        }
 855
 856        if (itv->has_cx23415 &&
 857            !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 858                                IVTV_DECODER_SIZE, "ivtv decoder")) {
 859                IVTV_ERR("Cannot request decoder memory region.\n");
 860                release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 861                release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 862                return -EIO;
 863        }
 864
 865        /* Check for bus mastering */
 866        pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 867        if (!(cmd & PCI_COMMAND_MASTER)) {
 868                IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 869                pci_set_master(pdev);
 870                pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 871                if (!(cmd & PCI_COMMAND_MASTER)) {
 872                        IVTV_ERR("Bus Mastering is not enabled\n");
 873                        if (itv->has_cx23415)
 874                                release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 875                                                   IVTV_DECODER_SIZE);
 876                        release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 877                        release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 878                        return -ENXIO;
 879                }
 880        }
 881        IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 882
 883        pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
 884
 885        if (pci_latency < 64 && ivtv_pci_latency) {
 886                IVTV_INFO("Unreasonably low latency timer, setting to 64 (was %d)\n",
 887                          pci_latency);
 888                pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
 889                pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
 890        }
 891        /* This config space value relates to DMA latencies. The
 892           default value 0x8080 is too low however and will lead
 893           to DMA errors. 0xffff is the max value which solves
 894           these problems. */
 895        pci_write_config_dword(pdev, 0x40, 0xffff);
 896
 897        IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, irq: %d, latency: %d, memory: 0x%llx\n",
 898                   pdev->device, pdev->revision, pdev->bus->number,
 899                   PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
 900                   pdev->irq, pci_latency, (u64)itv->base_addr);
 901
 902        return 0;
 903}
 904
 905static void ivtv_load_and_init_modules(struct ivtv *itv)
 906{
 907        u32 hw = itv->card->hw_all;
 908        unsigned i;
 909
 910        /* check which i2c devices are actually found */
 911        for (i = 0; i < 32; i++) {
 912                u32 device = BIT(i);
 913
 914                if (!(device & hw))
 915                        continue;
 916                if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
 917                        /* GPIO and TVEEPROM do not use i2c probing */
 918                        itv->hw_flags |= device;
 919                        continue;
 920                }
 921                if (ivtv_i2c_register(itv, i) == 0)
 922                        itv->hw_flags |= device;
 923        }
 924
 925        /* probe for legacy IR controllers that aren't in card definitions */
 926        if ((itv->hw_flags & IVTV_HW_IR_ANY) == 0)
 927                ivtv_i2c_new_ir_legacy(itv);
 928
 929        if (itv->card->hw_all & IVTV_HW_CX25840)
 930                itv->sd_video = ivtv_find_hw(itv, IVTV_HW_CX25840);
 931        else if (itv->card->hw_all & IVTV_HW_SAA717X)
 932                itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA717X);
 933        else if (itv->card->hw_all & IVTV_HW_SAA7114)
 934                itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7114);
 935        else
 936                itv->sd_video = ivtv_find_hw(itv, IVTV_HW_SAA7115);
 937        itv->sd_audio = ivtv_find_hw(itv, itv->card->hw_audio_ctrl);
 938        itv->sd_muxer = ivtv_find_hw(itv, itv->card->hw_muxer);
 939
 940        hw = itv->hw_flags;
 941
 942        if (itv->card->type == IVTV_CARD_CX23416GYC) {
 943                /* Several variations of this card exist, detect which card
 944                   type should be used. */
 945                if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 946                        itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 947                else if ((hw & IVTV_HW_UPD64031A) == 0)
 948                        itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 949        }
 950        else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
 951                 itv->card->type == IVTV_CARD_GV_MVPRX2E) {
 952                /* The crystal frequency of GVMVPRX is 24.576MHz */
 953                v4l2_subdev_call(itv->sd_video, video, s_crystal_freq,
 954                        SAA7115_FREQ_24_576_MHZ, SAA7115_FREQ_FL_UCGC);
 955        }
 956
 957        if (hw & IVTV_HW_CX25840) {
 958                itv->vbi.raw_decoder_line_size = 1444;
 959                itv->vbi.raw_decoder_sav_odd_field = 0x20;
 960                itv->vbi.raw_decoder_sav_even_field = 0x60;
 961                itv->vbi.sliced_decoder_line_size = 272;
 962                itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 963                itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 964        }
 965
 966        if (hw & IVTV_HW_SAA711X) {
 967                /* determine the exact saa711x model */
 968                itv->hw_flags &= ~IVTV_HW_SAA711X;
 969
 970                if (strstr(itv->sd_video->name, "saa7114")) {
 971                        itv->hw_flags |= IVTV_HW_SAA7114;
 972                        /* VBI is not yet supported by the saa7114 driver. */
 973                        itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 974                } else {
 975                        itv->hw_flags |= IVTV_HW_SAA7115;
 976                }
 977                itv->vbi.raw_decoder_line_size = 1443;
 978                itv->vbi.raw_decoder_sav_odd_field = 0x25;
 979                itv->vbi.raw_decoder_sav_even_field = 0x62;
 980                itv->vbi.sliced_decoder_line_size = 51;
 981                itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 982                itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 983        }
 984
 985        if (hw & IVTV_HW_SAA717X) {
 986                itv->vbi.raw_decoder_line_size = 1443;
 987                itv->vbi.raw_decoder_sav_odd_field = 0x25;
 988                itv->vbi.raw_decoder_sav_even_field = 0x62;
 989                itv->vbi.sliced_decoder_line_size = 51;
 990                itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 991                itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 992        }
 993}
 994
 995static int ivtv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
 996{
 997        int retval = 0;
 998        int vbi_buf_size;
 999        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
1273free_streams:
1274        ivtv_streams_cleanup(itv);
1275free_irq:
1276        free_irq(itv->pdev->irq, (void *)itv);
1277free_i2c:
1278        v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
1279        exit_ivtv_i2c(itv);
1280free_io:
1281        ivtv_iounmap(itv);
1282free_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);
1287free_worker:
1288        kthread_stop(itv->irq_worker_task);
1289err:
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
1299int 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
1391static void ivtv_remove(struct pci_dev *pdev)
1392{
1393        struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
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 */
1460static 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
1467static 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
1491static 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. */
1498EXPORT_SYMBOL(ivtv_set_irq_mask);
1499EXPORT_SYMBOL(ivtv_api);
1500EXPORT_SYMBOL(ivtv_vapi);
1501EXPORT_SYMBOL(ivtv_vapi_result);
1502EXPORT_SYMBOL(ivtv_clear_irq_mask);
1503EXPORT_SYMBOL(ivtv_debug);
1504#ifdef CONFIG_VIDEO_ADV_DEBUG
1505EXPORT_SYMBOL(ivtv_fw_debug);
1506#endif
1507EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1508EXPORT_SYMBOL(ivtv_udma_setup);
1509EXPORT_SYMBOL(ivtv_udma_unmap);
1510EXPORT_SYMBOL(ivtv_udma_alloc);
1511EXPORT_SYMBOL(ivtv_udma_prepare);
1512EXPORT_SYMBOL(ivtv_init_on_first_open);
1513EXPORT_SYMBOL(ivtv_firmware_check);
1514
1515module_init(module_start);
1516module_exit(module_cleanup);
1517