git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/ivtv/ivtv-driver.c

   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  * http://www.ivtvdriver.org
  27  *
  28  * -----
  29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  30  *                      and Takeru KOMORIYA<komoriya@paken.org>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  34  *
  35  * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
  36  *                using information from T.Adachi,Takeru KOMORIYA and others :-)
  37  *
  38  * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
  39  *                version by T.Adachi. Special thanks  Mr.Suzuki
  40  */
  41
  42 #include "ivtv-driver.h"
  43 #include "ivtv-version.h"
  44 #include "ivtv-fileops.h"
  45 #include "ivtv-i2c.h"
  46 #include "ivtv-firmware.h"
  47 #include "ivtv-queue.h"
  48 #include "ivtv-udma.h"
  49 #include "ivtv-irq.h"
  50 #include "ivtv-mailbox.h"
  51 #include "ivtv-streams.h"
  52 #include "ivtv-ioctl.h"
  53 #include "ivtv-cards.h"
  54 #include "ivtv-vbi.h"
  55 #include "ivtv-routing.h"
  56 #include "ivtv-gpio.h"
  57 #include "ivtv-yuv.h"
  58
  59 #include <media/tveeprom.h>
  60 #include <media/saa7115.h>
  61 #include <media/v4l2-chip-ident.h>
  62
  63 /* var to keep track of the number of array elements in use */
  64 int ivtv_cards_active = 0;
  65
  66 /* If you have already X v4l cards, then set this to X. This way
  67    the device numbers stay matched. Example: you have a WinTV card
  68    without radio and a PVR-350 with. Normally this would give a
  69    video1 device together with a radio0 device for the PVR. By
  70    setting this to 1 you ensure that radio0 is now also radio1. */
  71 int ivtv_first_minor = 0;
  72
  73 /* Master variable for all ivtv info */
  74 struct ivtv *ivtv_cards[IVTV_MAX_CARDS];
  75
  76 /* Protects ivtv_cards_active */
  77 DEFINE_SPINLOCK(ivtv_cards_lock);
  78
  79 /* add your revision and whatnot here */
  80 static struct pci_device_id ivtv_pci_tbl[] __devinitdata = {
  81         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV15,
  82          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  83         {PCI_VENDOR_ID_ICOMP, PCI_DEVICE_ID_IVTV16,
  84          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  85         {0,}
  86 };
  87
  88 MODULE_DEVICE_TABLE(pci,ivtv_pci_tbl);
  89
  90 /* Parameter declarations */
  91 static int cardtype[IVTV_MAX_CARDS];
  92 static int tuner[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  93                                      -1, -1, -1, -1, -1, -1, -1, -1,
  94                                      -1, -1, -1, -1, -1, -1, -1, -1,
  95                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  96 static int radio[IVTV_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  97                                      -1, -1, -1, -1, -1, -1, -1, -1,
  98                                      -1, -1, -1, -1, -1, -1, -1, -1,
  99                                      -1, -1, -1, -1, -1, -1, -1, -1 };
 100
 101 static unsigned int cardtype_c = 1;
 102 static unsigned int tuner_c = 1;
 103 static unsigned int radio_c = 1;
 104 static char pal[] = "--";
 105 static char secam[] = "--";
 106 static char ntsc[] = "-";
 107
 108 /* Buffers */
 109
 110 /* DMA Buffers, Default size in MB allocated */
 111 #define IVTV_DEFAULT_ENC_MPG_BUFFERS 4
 112 #define IVTV_DEFAULT_ENC_YUV_BUFFERS 2
 113 #define IVTV_DEFAULT_ENC_VBI_BUFFERS 1
 114 /* Exception: size in kB for this stream (MB is overkill) */
 115 #define IVTV_DEFAULT_ENC_PCM_BUFFERS 320
 116 #define IVTV_DEFAULT_DEC_MPG_BUFFERS 1
 117 #define IVTV_DEFAULT_DEC_YUV_BUFFERS 1
 118 /* Exception: size in kB for this stream (MB is way overkill) */
 119 #define IVTV_DEFAULT_DEC_VBI_BUFFERS 64
 120
 121 static int enc_mpg_buffers = IVTV_DEFAULT_ENC_MPG_BUFFERS;
 122 static int enc_yuv_buffers = IVTV_DEFAULT_ENC_YUV_BUFFERS;
 123 static int enc_vbi_buffers = IVTV_DEFAULT_ENC_VBI_BUFFERS;
 124 static int enc_pcm_buffers = IVTV_DEFAULT_ENC_PCM_BUFFERS;
 125 static int dec_mpg_buffers = IVTV_DEFAULT_DEC_MPG_BUFFERS;
 126 static int dec_yuv_buffers = IVTV_DEFAULT_DEC_YUV_BUFFERS;
 127 static int dec_vbi_buffers = IVTV_DEFAULT_DEC_VBI_BUFFERS;
 128
 129 static int ivtv_yuv_mode = 0;
 130 static int ivtv_yuv_threshold=-1;
 131 static int ivtv_pci_latency = 1;
 132
 133 int ivtv_debug = 0;
 134
 135 static int newi2c = -1;
 136
 137 module_param_array(tuner, int, &tuner_c, 0644);
 138 module_param_array(radio, bool, &radio_c, 0644);
 139 module_param_array(cardtype, int, &cardtype_c, 0644);
 140 module_param_string(pal, pal, sizeof(pal), 0644);
 141 module_param_string(secam, secam, sizeof(secam), 0644);
 142 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 143 module_param_named(debug,ivtv_debug, int, 0644);
 144 module_param(ivtv_pci_latency, int, 0644);
 145 module_param(ivtv_yuv_mode, int, 0644);
 146 module_param(ivtv_yuv_threshold, int, 0644);
 147 module_param(ivtv_first_minor, int, 0644);
 148
 149 module_param(enc_mpg_buffers, int, 0644);
 150 module_param(enc_yuv_buffers, int, 0644);
 151 module_param(enc_vbi_buffers, int, 0644);
 152 module_param(enc_pcm_buffers, int, 0644);
 153 module_param(dec_mpg_buffers, int, 0644);
 154 module_param(dec_yuv_buffers, int, 0644);
 155 module_param(dec_vbi_buffers, int, 0644);
 156
 157 module_param(newi2c, int, 0644);
 158
 159 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
 160                         "\t\t\tsee tuner.h for values");
 161 MODULE_PARM_DESC(radio,
 162                  "Enable or disable the radio. Use only if autodetection\n"
 163                  "\t\t\tfails. 0 = disable, 1 = enable");
 164 MODULE_PARM_DESC(cardtype,
 165                  "Only use this option if your card is not detected properly.\n"
 166                  "\t\tSpecify card type:\n"
 167                  "\t\t\t 1 = WinTV PVR 250\n"
 168                  "\t\t\t 2 = WinTV PVR 350\n"
 169                  "\t\t\t 3 = WinTV PVR-150 or PVR-500\n"
 170                  "\t\t\t 4 = AVerMedia M179\n"
 171                  "\t\t\t 5 = YUAN MPG600/Kuroutoshikou iTVC16-STVLP\n"
 172                  "\t\t\t 6 = YUAN MPG160/Kuroutoshikou iTVC15-STVLP\n"
 173                  "\t\t\t 7 = YUAN PG600/DIAMONDMM PVR-550 (CX Falcon 2)\n"
 174                  "\t\t\t 8 = Adaptec AVC-2410\n"
 175                  "\t\t\t 9 = Adaptec AVC-2010\n"
 176                  "\t\t\t10 = NAGASE TRANSGEAR 5000TV\n"
 177                  "\t\t\t11 = AOpen VA2000MAX-STN6\n"
 178                  "\t\t\t12 = YUAN MPG600GR/Kuroutoshikou CX23416GYC-STVLP\n"
 179                  "\t\t\t13 = I/O Data GV-MVP/RX\n"
 180                  "\t\t\t14 = I/O Data GV-MVP/RX2E\n"
 181                  "\t\t\t15 = GOTVIEW PCI DVD\n"
 182                  "\t\t\t16 = GOTVIEW PCI DVD2 Deluxe\n"
 183                  "\t\t\t17 = Yuan MPC622\n"
 184                  "\t\t\t18 = Digital Cowboy DCT-MTVP1\n"
 185                  "\t\t\t19 = Yuan PG600V2/GotView PCI DVD Lite\n"
 186                  "\t\t\t20 = Club3D ZAP-TV1x01\n"
 187                  "\t\t\t21 = AverTV MCE 116 Plus\n"
 188                  "\t\t\t 0 = Autodetect (default)\n"
 189                  "\t\t\t-1 = Ignore this card\n\t\t");
 190 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
 191 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
 192 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
 193 MODULE_PARM_DESC(debug,
 194                  "Debug level (bitmask). Default: 0\n"
 195                  "\t\t\t   1/0x0001: warning\n"
 196                  "\t\t\t   2/0x0002: info\n"
 197                  "\t\t\t   4/0x0004: mailbox\n"
 198                  "\t\t\t   8/0x0008: ioctl\n"
 199                  "\t\t\t  16/0x0010: file\n"
 200                  "\t\t\t  32/0x0020: dma\n"
 201                  "\t\t\t  64/0x0040: irq\n"
 202                  "\t\t\t 128/0x0080: decoder\n"
 203                  "\t\t\t 256/0x0100: yuv\n"
 204                  "\t\t\t 512/0x0200: i2c\n"
 205                  "\t\t\t1024/0x0400: high volume\n");
 206 MODULE_PARM_DESC(ivtv_pci_latency,
 207                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 208                  "\t\t\tDefault: Yes");
 209 MODULE_PARM_DESC(ivtv_yuv_mode,
 210                  "Specify the yuv playback mode:\n"
 211                  "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
 212                  "\t\t\tDefault: 0 (interlaced)");
 213 MODULE_PARM_DESC(ivtv_yuv_threshold,
 214                  "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
 215                  "\t\t\tDefault: 480");;
 216 MODULE_PARM_DESC(enc_mpg_buffers,
 217                  "Encoder MPG Buffers (in MB)\n"
 218                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
 219 MODULE_PARM_DESC(enc_yuv_buffers,
 220                  "Encoder YUV Buffers (in MB)\n"
 221                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
 222 MODULE_PARM_DESC(enc_vbi_buffers,
 223                  "Encoder VBI Buffers (in MB)\n"
 224                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
 225 MODULE_PARM_DESC(enc_pcm_buffers,
 226                  "Encoder PCM buffers (in kB)\n"
 227                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
 228 MODULE_PARM_DESC(dec_mpg_buffers,
 229                  "Decoder MPG buffers (in MB)\n"
 230                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
 231 MODULE_PARM_DESC(dec_yuv_buffers,
 232                  "Decoder YUV buffers (in MB)\n"
 233                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
 234 MODULE_PARM_DESC(dec_vbi_buffers,
 235                  "Decoder VBI buffers (in kB)\n"
 236                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
 237 MODULE_PARM_DESC(newi2c,
 238                  "Use new I2C implementation\n"
 239                  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
 240                  "\t\t\tDefault is autodetect");
 241
 242 MODULE_PARM_DESC(ivtv_first_minor, "Set minor assigned to first card");
 243
 244 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 245 MODULE_DESCRIPTION("CX23415/CX23416 driver");
 246 MODULE_SUPPORTED_DEVICE
 247     ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
 248                 "\t\t\tYuan MPG series and similar)");
 249 MODULE_LICENSE("GPL");
 250
 251 MODULE_VERSION(IVTV_VERSION);
 252
 253 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
 254 {
 255         itv->irqmask &= ~mask;
 256         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 257 }
 258
 259 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
 260 {
 261         itv->irqmask |= mask;
 262         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 263 }
 264
 265 int ivtv_set_output_mode(struct ivtv *itv, int mode)
 266 {
 267     int old_mode;
 268
 269     spin_lock(&itv->lock);
 270     old_mode = itv->output_mode;
 271     if (old_mode == 0)
 272         itv->output_mode = old_mode = mode;
 273     spin_unlock(&itv->lock);
 274     return old_mode;
 275 }
 276
 277 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
 278 {
 279         switch (itv->output_mode) {
 280         case OUT_MPG:
 281                 return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 282         case OUT_YUV:
 283                 return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 284         default:
 285                 return NULL;
 286         }
 287 }
 288
 289 int ivtv_waitq(wait_queue_head_t *waitq)
 290 {
 291         DEFINE_WAIT(wait);
 292
 293         prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
 294         schedule();
 295         finish_wait(waitq, &wait);
 296         return signal_pending(current) ? -EINTR : 0;
 297 }
 298
 299 /* Generic utility functions */
 300 int ivtv_msleep_timeout(unsigned int msecs, int intr)
 301 {
 302         int ret;
 303         int timeout = msecs_to_jiffies(msecs);
 304
 305         do {
 306                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 307                 timeout = schedule_timeout(timeout);
 308                 if (intr && (ret = signal_pending(current)))
 309                         return ret;
 310         } while (timeout);
 311         return 0;
 312 }
 313
 314 /* Release ioremapped memory */
 315 static void ivtv_iounmap(struct ivtv *itv)
 316 {
 317         if (itv == NULL)
 318                 return;
 319
 320         /* Release registers memory */
 321         if (itv->reg_mem != NULL) {
 322                 IVTV_DEBUG_INFO("releasing reg_mem\n");
 323                 iounmap(itv->reg_mem);
 324                 itv->reg_mem = NULL;
 325         }
 326         /* Release io memory */
 327         if (itv->has_cx23415 && itv->dec_mem != NULL) {
 328                 IVTV_DEBUG_INFO("releasing dec_mem\n");
 329                 iounmap(itv->dec_mem);
 330         }
 331         itv->dec_mem = NULL;
 332
 333         /* Release io memory */
 334         if (itv->enc_mem != NULL) {
 335                 IVTV_DEBUG_INFO("releasing enc_mem\n");
 336                 iounmap(itv->enc_mem);
 337                 itv->enc_mem = NULL;
 338         }
 339 }
 340
 341 /* Hauppauge card? get values from tveeprom */
 342 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
 343 {
 344         u8 eedata[256];
 345
 346         itv->i2c_client.addr = 0xA0 >> 1;
 347         tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
 348         tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
 349 }
 350
 351 static void ivtv_process_eeprom(struct ivtv *itv)
 352 {
 353         struct tveeprom tv;
 354         int pci_slot = PCI_SLOT(itv->dev->devfn);
 355
 356         ivtv_read_eeprom(itv, &tv);
 357
 358         /* Many thanks to Steven Toth from Hauppauge for providing the
 359            model numbers */
 360         switch (tv.model) {
 361                 /* In a few cases the PCI subsystem IDs do not correctly
 362                    identify the card. A better method is to check the
 363                    model number from the eeprom instead. */
 364                 case 30012 ... 30039:  /* Low profile PVR250 */
 365                 case 32000 ... 32999:
 366                 case 48000 ... 48099:  /* 48??? range are PVR250s with a cx23415 */
 367                 case 48400 ... 48599:
 368                         itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
 369                         break;
 370                 case 48100 ... 48399:
 371                 case 48600 ... 48999:
 372                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
 373                         break;
 374                 case 23000 ... 23999:  /* PVR500 */
 375                 case 25000 ... 25999:  /* Low profile PVR150 */
 376                 case 26000 ... 26999:  /* Regular PVR150 */
 377                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 378                         break;
 379                 case 0:
 380                         IVTV_ERR("Invalid EEPROM\n");
 381                         return;
 382                 default:
 383                         IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
 384                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 385                         break;
 386         }
 387
 388         switch (tv.model) {
 389                 /* Old style PVR350 (with an saa7114) uses this input for
 390                    the tuner. */
 391                 case 48254:
 392                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
 393                         break;
 394                 default:
 395                         break;
 396         }
 397
 398         itv->v4l2_cap = itv->card->v4l2_capabilities;
 399         itv->card_name = itv->card->name;
 400
 401         /* If this is a PVR500 then it should be possible to detect whether it is the
 402            first or second unit by looking at the subsystem device ID: is bit 4 is
 403            set, then it is the second unit (according to info from Hauppauge).
 404
 405            However, while this works for most cards, I have seen a few PVR500 cards
 406            where both units have the same subsystem ID.
 407
 408            So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
 409            PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
 410            it is the second unit. It is possible that it is a different slot when ivtv is
 411            used in Xen, in that case I ignore this card here. The worst that can happen
 412            is that the card presents itself with a non-working radio device.
 413
 414            This detection is needed since the eeprom reports incorrectly that a radio is
 415            present on the second unit. */
 416         if (tv.model / 1000 == 23) {
 417                 itv->card_name = "WinTV PVR 500";
 418                 if (pci_slot == 8 || pci_slot == 9) {
 419                         int is_first = (pci_slot & 1) == 0;
 420
 421                         itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
 422                                                     "WinTV PVR 500 (unit #2)";
 423                         if (!is_first) {
 424                                 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
 425                                 tv.has_radio = 0;
 426                         }
 427                 }
 428         }
 429         IVTV_INFO("Autodetected %s\n", itv->card_name);
 430
 431         switch (tv.tuner_hauppauge_model) {
 432                 case 85:
 433                 case 99:
 434                 case 112:
 435                         itv->pvr150_workaround = 1;
 436                         break;
 437                 default:
 438                         break;
 439         }
 440         if (tv.tuner_type == TUNER_ABSENT)
 441                 IVTV_ERR("tveeprom cannot autodetect tuner!");
 442
 443         if (itv->options.tuner == -1)
 444                 itv->options.tuner = tv.tuner_type;
 445         if (itv->options.radio == -1)
 446                 itv->options.radio = (tv.has_radio != 0);
 447         /* only enable newi2c if an IR blaster is present */
 448         /* FIXME: for 2.6.20 the test against 2 should be removed */
 449         if (itv->options.newi2c == -1 && tv.has_ir != -1 && tv.has_ir != 2) {
 450                 itv->options.newi2c = (tv.has_ir & 2) ? 1 : 0;
 451                 if (itv->options.newi2c) {
 452                     IVTV_INFO("Reopen i2c bus for IR-blaster support\n");
 453                     exit_ivtv_i2c(itv);
 454                     init_ivtv_i2c(itv);
 455                 }
 456         }
 457
 458         if (itv->std != 0)
 459                 /* user specified tuner standard */
 460                 return;
 461
 462         /* autodetect tuner standard */
 463         if (tv.tuner_formats & V4L2_STD_PAL) {
 464                 IVTV_DEBUG_INFO("PAL tuner detected\n");
 465                 itv->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 466         } else if (tv.tuner_formats & V4L2_STD_NTSC) {
 467                 IVTV_DEBUG_INFO("NTSC tuner detected\n");
 468                 itv->std |= V4L2_STD_NTSC_M;
 469         } else if (tv.tuner_formats & V4L2_STD_SECAM) {
 470                 IVTV_DEBUG_INFO("SECAM tuner detected\n");
 471                 itv->std |= V4L2_STD_SECAM_L;
 472         } else {
 473                 IVTV_INFO("No tuner detected, default to NTSC-M\n");
 474                 itv->std |= V4L2_STD_NTSC_M;
 475         }
 476 }
 477
 478 static v4l2_std_id ivtv_parse_std(struct ivtv *itv)
 479 {
 480         switch (pal[0]) {
 481                 case '6':
 482                         return V4L2_STD_PAL_60;
 483                 case 'b':
 484                 case 'B':
 485                 case 'g':
 486                 case 'G':
 487                         return V4L2_STD_PAL_BG;
 488                 case 'h':
 489                 case 'H':
 490                         return V4L2_STD_PAL_H;
 491                 case 'n':
 492                 case 'N':
 493                         if (pal[1] == 'c' || pal[1] == 'C')
 494                                 return V4L2_STD_PAL_Nc;
 495                         return V4L2_STD_PAL_N;
 496                 case 'i':
 497                 case 'I':
 498                         return V4L2_STD_PAL_I;
 499                 case 'd':
 500                 case 'D':
 501                 case 'k':
 502                 case 'K':
 503                         return V4L2_STD_PAL_DK;
 504                 case 'M':
 505                 case 'm':
 506                         return V4L2_STD_PAL_M;
 507                 case '-':
 508                         break;
 509                 default:
 510                         IVTV_WARN("pal= argument not recognised\n");
 511                         return 0;
 512         }
 513
 514         switch (secam[0]) {
 515                 case 'b':
 516                 case 'B':
 517                 case 'g':
 518                 case 'G':
 519                 case 'h':
 520                 case 'H':
 521                         return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 522                 case 'd':
 523                 case 'D':
 524                 case 'k':
 525                 case 'K':
 526                         return V4L2_STD_SECAM_DK;
 527                 case 'l':
 528                 case 'L':
 529                         if (secam[1] == 'C' || secam[1] == 'c')
 530                                 return V4L2_STD_SECAM_LC;
 531                         return V4L2_STD_SECAM_L;
 532                 case '-':
 533                         break;
 534                 default:
 535                         IVTV_WARN("secam= argument not recognised\n");
 536                         return 0;
 537         }
 538
 539         switch (ntsc[0]) {
 540                 case 'm':
 541                 case 'M':
 542                         return V4L2_STD_NTSC_M;
 543                 case 'j':
 544                 case 'J':
 545                         return V4L2_STD_NTSC_M_JP;
 546                 case 'k':
 547                 case 'K':
 548                         return V4L2_STD_NTSC_M_KR;
 549                 case '-':
 550                         break;
 551                 default:
 552                         IVTV_WARN("ntsc= argument not recognised\n");
 553                         return 0;
 554         }
 555
 556         /* no match found */
 557         return 0;
 558 }
 559
 560 static void ivtv_process_options(struct ivtv *itv)
 561 {
 562         const char *chipname;
 563         int i, j;
 564
 565         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers * 1024;
 566         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers * 1024;
 567         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers * 1024;
 568         itv->options.kilobytes[IVTV_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
 569         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_MPG] = dec_mpg_buffers * 1024;
 570         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_YUV] = dec_yuv_buffers * 1024;
 571         itv->options.kilobytes[IVTV_DEC_STREAM_TYPE_VBI] = dec_vbi_buffers;
 572         itv->options.cardtype = cardtype[itv->num];
 573         itv->options.tuner = tuner[itv->num];
 574         itv->options.radio = radio[itv->num];
 575         itv->options.newi2c = newi2c;
 576
 577         itv->std = ivtv_parse_std(itv);
 578         itv->has_cx23415 = (itv->dev->device == PCI_DEVICE_ID_IVTV15);
 579         chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
 580         if (itv->options.cardtype == -1) {
 581                 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
 582                 return;
 583         }
 584         if ((itv->card = ivtv_get_card(itv->options.cardtype - 1))) {
 585                 IVTV_INFO("User specified %s card (detected %s based chip)\n",
 586                                 itv->card->name, chipname);
 587         } else if (itv->options.cardtype != 0) {
 588                 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
 589         }
 590         if (itv->card == NULL) {
 591                 if (itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
 592                     itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
 593                     itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
 594                         itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
 595                         IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
 596                                         chipname);
 597                 }
 598         }
 599         if (itv->card == NULL) {
 600                 for (i = 0; (itv->card = ivtv_get_card(i)); i++) {
 601                         if (itv->card->pci_list == NULL)
 602                                 continue;
 603                         for (j = 0; itv->card->pci_list[j].device; j++) {
 604                                 if (itv->dev->device !=
 605                                     itv->card->pci_list[j].device)
 606                                         continue;
 607                                 if (itv->dev->subsystem_vendor !=
 608                                     itv->card->pci_list[j].subsystem_vendor)
 609                                         continue;
 610                                 if (itv->dev->subsystem_device !=
 611                                     itv->card->pci_list[j].subsystem_device)
 612                                         continue;
 613                                 IVTV_INFO("Autodetected %s card (%s based)\n",
 614                                                 itv->card->name, chipname);
 615                                 goto done;
 616                         }
 617                 }
 618         }
 619 done:
 620
 621         if (itv->card == NULL) {
 622                 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 623                 IVTV_ERR("Unknown card: vendor/device: %04x/%04x\n",
 624                      itv->dev->vendor, itv->dev->device);
 625                 IVTV_ERR("              subsystem vendor/device: %04x/%04x\n",
 626                      itv->dev->subsystem_vendor, itv->dev->subsystem_device);
 627                 IVTV_ERR("              %s based\n", chipname);
 628                 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
 629                 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 630                 IVTV_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
 631                 IVTV_ERR("Prefix your subject line with [UNKNOWN CARD].\n");
 632         }
 633         itv->v4l2_cap = itv->card->v4l2_capabilities;
 634         itv->card_name = itv->card->name;
 635 }
 636
 637 /* Precondition: the ivtv structure has been memset to 0. Only
 638    the dev and num fields have been filled in.
 639    No assumptions on the card type may be made here (see ivtv_init_struct2
 640    for that).
 641  */
 642 static int __devinit ivtv_init_struct1(struct ivtv *itv)
 643 {
 644         itv->base_addr = pci_resource_start(itv->dev, 0);
 645         itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
 646         itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
 647
 648         mutex_init(&itv->serialize_lock);
 649         mutex_init(&itv->i2c_bus_lock);
 650         mutex_init(&itv->udma.lock);
 651
 652         spin_lock_init(&itv->lock);
 653         spin_lock_init(&itv->dma_reg_lock);
 654
 655         itv->irq_work_queues = create_workqueue(itv->name);
 656         if (itv->irq_work_queues == NULL) {
 657                 IVTV_ERR("Could not create ivtv workqueue\n");
 658                 return -1;
 659         }
 660
 661         INIT_WORK(&itv->irq_work_queue, ivtv_irq_work_handler);
 662
 663         /* start counting open_id at 1 */
 664         itv->open_id = 1;
 665
 666         /* Initial settings */
 667         cx2341x_fill_defaults(&itv->params);
 668         itv->params.port = CX2341X_PORT_MEMORY;
 669         itv->params.capabilities = CX2341X_CAP_HAS_SLICED_VBI;
 670         init_waitqueue_head(&itv->eos_waitq);
 671         init_waitqueue_head(&itv->event_waitq);
 672         init_waitqueue_head(&itv->vsync_waitq);
 673         init_waitqueue_head(&itv->dma_waitq);
 674         init_timer(&itv->dma_timer);
 675         itv->dma_timer.function = ivtv_unfinished_dma;
 676         itv->dma_timer.data = (unsigned long)itv;
 677
 678         itv->cur_dma_stream = -1;
 679         itv->cur_pio_stream = -1;
 680         itv->audio_stereo_mode = AUDIO_STEREO;
 681         itv->audio_bilingual_mode = AUDIO_MONO_LEFT;
 682
 683         /* Ctrls */
 684         itv->speed = 1000;
 685
 686         /* VBI */
 687         itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
 688         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 689
 690         /* OSD */
 691         itv->osd_global_alpha_state = 1;
 692         itv->osd_global_alpha = 255;
 693
 694         /* YUV */
 695         atomic_set(&itv->yuv_info.next_dma_frame, -1);
 696         itv->yuv_info.lace_mode = ivtv_yuv_mode;
 697         itv->yuv_info.lace_threshold = ivtv_yuv_threshold;
 698         return 0;
 699 }
 700
 701 /* Second initialization part. Here the card type has been
 702    autodetected. */
 703 static void __devinit ivtv_init_struct2(struct ivtv *itv)
 704 {
 705         int i;
 706
 707         for (i = 0; i < IVTV_CARD_MAX_VIDEO_INPUTS; i++)
 708                 if (itv->card->video_inputs[i].video_type == 0)
 709                         break;
 710         itv->nof_inputs = i;
 711         for (i = 0; i < IVTV_CARD_MAX_AUDIO_INPUTS; i++)
 712                 if (itv->card->audio_inputs[i].audio_type == 0)
 713                         break;
 714         itv->nof_audio_inputs = i;
 715
 716         if (itv->card->hw_all & IVTV_HW_CX25840) {
 717                 itv->vbi.sliced_size = 288;  /* multiple of 16, real size = 284 */
 718         } else {
 719                 itv->vbi.sliced_size = 64;   /* multiple of 16, real size = 52 */
 720         }
 721
 722         /* Find tuner input */
 723         for (i = 0; i < itv->nof_inputs; i++) {
 724                 if (itv->card->video_inputs[i].video_type ==
 725                                 IVTV_CARD_INPUT_VID_TUNER)
 726                         break;
 727         }
 728         if (i == itv->nof_inputs)
 729                 i = 0;
 730         itv->active_input = i;
 731         itv->audio_input = itv->card->video_inputs[i].audio_index;
 732         if (itv->card->hw_all & IVTV_HW_CX25840)
 733                 itv->video_dec_func = ivtv_cx25840;
 734         else if (itv->card->hw_all & IVTV_HW_SAA717X)
 735                 itv->video_dec_func = ivtv_saa717x;
 736         else
 737                 itv->video_dec_func = ivtv_saa7115;
 738 }
 739
 740 static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
 741                           const struct pci_device_id *pci_id)
 742 {
 743         u16 cmd;
 744         u8 card_rev;
 745         unsigned char pci_latency;
 746
 747         IVTV_DEBUG_INFO("Enabling pci device\n");
 748
 749         if (pci_enable_device(dev)) {
 750                 IVTV_ERR("Can't enable device %d!\n", itv->num);
 751                 return -EIO;
 752         }
 753         if (pci_set_dma_mask(dev, 0xffffffff)) {
 754                 IVTV_ERR("No suitable DMA available on card %d.\n", itv->num);
 755                 return -EIO;
 756         }
 757         if (!request_mem_region(itv->base_addr, IVTV_ENCODER_SIZE, "ivtv encoder")) {
 758                 IVTV_ERR("Cannot request encoder memory region on card %d.\n", itv->num);
 759                 return -EIO;
 760         }
 761
 762         if (!request_mem_region(itv->base_addr + IVTV_REG_OFFSET,
 763                                 IVTV_REG_SIZE, "ivtv registers")) {
 764                 IVTV_ERR("Cannot request register memory region on card %d.\n", itv->num);
 765                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 766                 return -EIO;
 767         }
 768
 769         if (itv->has_cx23415 &&
 770             !request_mem_region(itv->base_addr + IVTV_DECODER_OFFSET,
 771                                 IVTV_DECODER_SIZE, "ivtv decoder")) {
 772                 IVTV_ERR("Cannot request decoder memory region on card %d.\n", itv->num);
 773                 release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
 774                 release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
 775                 return -EIO;
 776         }
 777
 778         /* Check for bus mastering */
 779         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 780         if (!(cmd & PCI_COMMAND_MASTER)) {
 781                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
 782                 pci_set_master(dev);
 783                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
 784                 if (!(cmd & PCI_COMMAND_MASTER)) {
 785                         IVTV_ERR("Bus Mastering is not enabled\n");
 786                         return -ENXIO;
 787                 }
 788         }
 789         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 790
 791         pci_read_config_byte(dev, PCI_CLASS_REVISION, &card_rev);
 792         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 793
 794         if (pci_latency < 64 && ivtv_pci_latency) {
 795                 IVTV_INFO("Unreasonably low latency timer, "
 796                                "setting to 64 (was %d)\n", pci_latency);
 797                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
 798                 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
 799         }
 800         /* This config space value relates to DMA latencies. The
 801            default value 0x8080 is too low however and will lead
 802            to DMA errors. 0xffff is the max value which solves
 803            these problems. */
 804         pci_write_config_dword(dev, 0x40, 0xffff);
 805
 806         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
 807                    "irq: %d, latency: %d, memory: 0x%lx\n",
 808                    itv->dev->device, card_rev, dev->bus->number,
 809                    PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 810                    itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
 811
 812         return 0;
 813 }
 814
 815 static void ivtv_request_module(struct ivtv *itv, const char *name)
 816 {
 817         if (request_module(name) != 0) {
 818                 IVTV_ERR("Failed to load module %s\n", name);
 819         } else {
 820                 IVTV_DEBUG_INFO("Loaded module %s\n", name);
 821         }
 822 }
 823
 824 static void ivtv_load_and_init_modules(struct ivtv *itv)
 825 {
 826         u32 hw = itv->card->hw_all;
 827         int i;
 828
 829         /* load modules */
 830 #ifndef CONFIG_VIDEO_TUNER
 831         if (hw & IVTV_HW_TUNER) {
 832                 if (itv->options.tuner == TUNER_XCEIVE_XC3028) {
 833                         IVTV_INFO("Xceive tuner not yet supported, only composite and S-Video inputs will be available\n");
 834                         itv->tunerid = 1;
 835                 }
 836                 else {
 837                         ivtv_request_module(itv, "tuner");
 838                 }
 839         }
 840 #endif
 841 #ifndef CONFIG_VIDEO_CX25840
 842         if (hw & IVTV_HW_CX25840)
 843                 ivtv_request_module(itv, "cx25840");
 844 #endif
 845 #ifndef CONFIG_VIDEO_SAA711X
 846         if (hw & IVTV_HW_SAA711X)
 847                 ivtv_request_module(itv, "saa7115");
 848 #endif
 849 #ifndef CONFIG_VIDEO_SAA7127
 850         if (hw & IVTV_HW_SAA7127)
 851                 ivtv_request_module(itv, "saa7127");
 852 #endif
 853         if (hw & IVTV_HW_SAA717X)
 854                 ivtv_request_module(itv, "saa717x");
 855 #ifndef CONFIG_VIDEO_UPD64031A
 856         if (hw & IVTV_HW_UPD64031A)
 857                 ivtv_request_module(itv, "upd64031a");
 858 #endif
 859 #ifndef CONFIG_VIDEO_UPD64083
 860         if (hw & IVTV_HW_UPD6408X)
 861                 ivtv_request_module(itv, "upd64083");
 862 #endif
 863 #ifndef CONFIG_VIDEO_MSP3400
 864         if (hw & IVTV_HW_MSP34XX)
 865                 ivtv_request_module(itv, "msp3400");
 866 #endif
 867 #ifndef CONFIG_VIDEO_VP27SMPX
 868         if (hw & IVTV_HW_VP27SMPX)
 869                 ivtv_request_module(itv, "vp27smpx");
 870 #endif
 871         if (hw & IVTV_HW_TVAUDIO)
 872                 ivtv_request_module(itv, "tvaudio");
 873 #ifndef CONFIG_VIDEO_WM8775
 874         if (hw & IVTV_HW_WM8775)
 875                 ivtv_request_module(itv, "wm8775");
 876 #endif
 877 #ifndef CONFIG_VIDEO_WM8739
 878         if (hw & IVTV_HW_WM8739)
 879                 ivtv_request_module(itv, "wm8739");
 880 #endif
 881 #ifndef CONFIG_VIDEO_CS53L32A
 882         if (hw & IVTV_HW_CS53L32A)
 883                 ivtv_request_module(itv, "cs53l32a");
 884 #endif
 885
 886         /* check which i2c devices are actually found */
 887         for (i = 0; i < 32; i++) {
 888                 u32 device = 1 << i;
 889
 890                 if (!(device & hw))
 891                         continue;
 892                 if (device == IVTV_HW_GPIO) {
 893                         /* GPIO is always available */
 894                         itv->hw_flags |= IVTV_HW_GPIO;
 895                         continue;
 896                 }
 897                 if (ivtv_i2c_hw_addr(itv, device) > 0)
 898                         itv->hw_flags |= device;
 899         }
 900
 901         hw = itv->hw_flags;
 902
 903         if (itv->card->type == IVTV_CARD_CX23416GYC) {
 904                 /* Several variations of this card exist, detect which card
 905                    type should be used. */
 906                 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 907                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 908                 else if ((hw & IVTV_HW_UPD64031A) == 0)
 909                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 910         }
 911         else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
 912                  itv->card->type == IVTV_CARD_GV_MVPRX2E) {
 913                 struct v4l2_crystal_freq crystal_freq;
 914
 915                 /* The crystal frequency of GVMVPRX is 24.576MHz */
 916                 crystal_freq.freq = SAA7115_FREQ_24_576_MHZ;
 917                 crystal_freq.flags = SAA7115_FREQ_FL_UCGC;
 918                 itv->video_dec_func(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
 919         }
 920
 921         if (hw & IVTV_HW_CX25840) {
 922                 itv->vbi.raw_decoder_line_size = 1444;
 923                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 924                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 925                 itv->vbi.sliced_decoder_line_size = 272;
 926                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 927                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 928         }
 929
 930         if (hw & IVTV_HW_SAA711X) {
 931                 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
 932
 933                 /* determine the exact saa711x model */
 934                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 935
 936                 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
 937                 if (v.ident == V4L2_IDENT_SAA7114) {
 938                         itv->hw_flags |= IVTV_HW_SAA7114;
 939                         /* VBI is not yet supported by the saa7114 driver. */
 940                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 941                 }
 942                 else {
 943                         itv->hw_flags |= IVTV_HW_SAA7115;
 944                 }
 945                 itv->vbi.raw_decoder_line_size = 1443;
 946                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 947                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 948                 itv->vbi.sliced_decoder_line_size = 51;
 949                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 950                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 951         }
 952
 953         if (hw & IVTV_HW_SAA717X) {
 954                 itv->vbi.raw_decoder_line_size = 1443;
 955                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 956                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 957                 itv->vbi.sliced_decoder_line_size = 51;
 958                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 959                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 960         }
 961 }
 962
 963 static int __devinit ivtv_probe(struct pci_dev *dev,
 964                                 const struct pci_device_id *pci_id)
 965 {
 966         int retval = 0;
 967         int yuv_buf_size;
 968         int vbi_buf_size;
 969         struct ivtv *itv;
 970
 971         spin_lock(&ivtv_cards_lock);
 972
 973         /* Make sure we've got a place for this card */
 974         if (ivtv_cards_active == IVTV_MAX_CARDS) {
 975                 printk(KERN_ERR "ivtv:  Maximum number of cards detected (%d)\n",
 976                               ivtv_cards_active);
 977                 spin_unlock(&ivtv_cards_lock);
 978                 return -ENOMEM;
 979         }
 980
 981         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
 982         if (itv == 0) {
 983                 spin_unlock(&ivtv_cards_lock);
 984                 return -ENOMEM;
 985         }
 986         ivtv_cards[ivtv_cards_active] = itv;
 987         itv->dev = dev;
 988         itv->num = ivtv_cards_active++;
 989         snprintf(itv->name, sizeof(itv->name) - 1, "ivtv%d", itv->num);
 990         IVTV_INFO("Initializing card #%d\n", itv->num);
 991
 992         spin_unlock(&ivtv_cards_lock);
 993
 994         ivtv_process_options(itv);
 995         if (itv->options.cardtype == -1) {
 996                 retval = -ENODEV;
 997                 goto err;
 998         }
 999         if (ivtv_init_struct1(itv)) {
1000                 retval = -ENOMEM;
1001                 goto err;
1002         }
1003
1004         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
1005
1006         /* PCI Device Setup */
1007         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
1008                 if (retval == -EIO)
1009                         goto free_workqueue;
1010                 else if (retval == -ENXIO)
1011                         goto free_mem;
1012         }
1013         /* save itv in the pci struct for later use */
1014         pci_set_drvdata(dev, itv);
1015
1016         /* map io memory */
1017         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1018                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1019         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1020                                        IVTV_ENCODER_SIZE);
1021         if (!itv->enc_mem) {
1022                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1023                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1024                 retval = -ENOMEM;
1025                 goto free_mem;
1026         }
1027
1028         if (itv->has_cx23415) {
1029                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1030                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1031                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1032                                 IVTV_DECODER_SIZE);
1033                 if (!itv->dec_mem) {
1034                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1035                         IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1036                         retval = -ENOMEM;
1037                         goto free_mem;
1038                 }
1039         }
1040         else {
1041                 itv->dec_mem = itv->enc_mem;
1042         }
1043
1044         /* map registers memory */
1045         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1046                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1047         itv->reg_mem =
1048             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1049         if (!itv->reg_mem) {
1050                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1051                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1052                 retval = -ENOMEM;
1053                 goto free_io;
1054         }
1055
1056         /* Check yuv output filter table */
1057         if (itv->has_cx23415) ivtv_yuv_filter_check(itv);
1058
1059         ivtv_gpio_init(itv);
1060
1061         /* active i2c  */
1062         IVTV_DEBUG_INFO("activating i2c...\n");
1063         if (init_ivtv_i2c(itv)) {
1064                 IVTV_ERR("Could not initialize i2c\n");
1065                 goto free_io;
1066         }
1067
1068         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1069
1070         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1071 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1072                 ivtv_request_module(itv, "tveeprom");
1073 #endif
1074                 /* Based on the model number the cardtype may be changed.
1075                    The PCI IDs are not always reliable. */
1076                 ivtv_process_eeprom(itv);
1077         }
1078
1079         if (itv->std == 0) {
1080                 itv->std = V4L2_STD_NTSC_M;
1081         }
1082
1083         if (itv->options.tuner == -1) {
1084                 int i;
1085
1086                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1087                         if ((itv->std & itv->card->tuners[i].std) == 0)
1088                                 continue;
1089                         itv->options.tuner = itv->card->tuners[i].tuner;
1090                         break;
1091                 }
1092         }
1093         /* if no tuner was found, then pick the first tuner in the card list */
1094         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1095                 itv->std = itv->card->tuners[0].std;
1096                 itv->options.tuner = itv->card->tuners[0].tuner;
1097         }
1098         if (itv->options.radio == -1)
1099                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1100
1101         /* The card is now fully identified, continue with card-specific
1102            initialization. */
1103         ivtv_init_struct2(itv);
1104
1105         ivtv_load_and_init_modules(itv);
1106
1107         if (itv->std & V4L2_STD_525_60) {
1108                 itv->is_60hz = 1;
1109                 itv->is_out_60hz = 1;
1110         } else {
1111                 itv->is_50hz = 1;
1112                 itv->is_out_50hz = 1;
1113         }
1114         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1115
1116         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1117         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1118         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1119
1120         /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1121         yuv_buf_size = itv->is_60hz ? 0x15180 : 0x19500;
1122         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = yuv_buf_size / 2;
1123         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = yuv_buf_size / 8;
1124
1125         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1126            It is possible to switch between PAL and NTSC, so we need to
1127            take the largest size here. */
1128         /* 1456 is multiple of 16, real size = 1444 */
1129         itv->vbi.raw_size = 1456;
1130         /* We use a buffer size of 1/2 of the total size needed for a
1131            frame. This is actually very useful, since we now receive
1132            a field at a time and that makes 'compressing' the raw data
1133            down to size by stripping off the SAV codes a lot easier.
1134            Note: having two different buffer sizes prevents standard
1135            switching on the fly. We need to find a better solution... */
1136         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1137         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1138         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1139
1140         if (itv->options.radio > 0)
1141                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1142
1143         if (itv->options.tuner > -1 && itv->tunerid == 0) {
1144                 struct tuner_setup setup;
1145
1146                 setup.addr = ADDR_UNSET;
1147                 setup.type = itv->options.tuner;
1148                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1149                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1150         }
1151
1152         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1153            are not. */
1154         itv->tuner_std = itv->std;
1155
1156         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1157                 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1158         }
1159
1160         retval = ivtv_streams_setup(itv);
1161         if (retval) {
1162                 IVTV_ERR("Error %d setting up streams\n", retval);
1163                 goto free_i2c;
1164         }
1165
1166         IVTV_DEBUG_IRQ("Masking interrupts\n");
1167         /* clear interrupt mask, effectively disabling interrupts */
1168         ivtv_set_irq_mask(itv, 0xffffffff);
1169
1170         /* Register IRQ */
1171         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1172                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1173         if (retval) {
1174                 IVTV_ERR("Failed to register irq %d\n", retval);
1175                 goto free_streams;
1176         }
1177         retval = ivtv_streams_register(itv);
1178         if (retval) {
1179                 IVTV_ERR("Error %d registering devices\n", retval);
1180                 goto free_irq;
1181         }
1182         IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1183         return 0;
1184
1185       free_irq:
1186         free_irq(itv->dev->irq, (void *)itv);
1187       free_streams:
1188         ivtv_streams_cleanup(itv);
1189       free_i2c:
1190         exit_ivtv_i2c(itv);
1191       free_io:
1192         ivtv_iounmap(itv);
1193       free_mem:
1194         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1195         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1196         if (itv->has_cx23415)
1197                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1198       free_workqueue:
1199         destroy_workqueue(itv->irq_work_queues);
1200       err:
1201         if (retval == 0)
1202                 retval = -ENODEV;
1203         IVTV_ERR("Error %d on initialization\n", retval);
1204
1205         spin_lock(&ivtv_cards_lock);
1206         kfree(ivtv_cards[ivtv_cards_active]);
1207         ivtv_cards[ivtv_cards_active] = NULL;
1208         spin_unlock(&ivtv_cards_lock);
1209         return retval;
1210 }
1211
1212 int ivtv_init_on_first_open(struct ivtv *itv)
1213 {
1214         struct v4l2_frequency vf;
1215         int fw_retry_count = 3;
1216         int video_input;
1217
1218         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1219                 return -ENXIO;
1220
1221         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1222                 return 0;
1223
1224         while (--fw_retry_count > 0) {
1225                 /* load firmware */
1226                 if (ivtv_firmware_init(itv) == 0)
1227                         break;
1228                 if (fw_retry_count > 1)
1229                         IVTV_WARN("Retry loading firmware\n");
1230         }
1231
1232         if (fw_retry_count == 0) {
1233                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1234                 return -ENXIO;
1235         }
1236
1237         /* Try and get firmware versions */
1238         IVTV_DEBUG_INFO("Getting firmware version..\n");
1239         ivtv_firmware_versions(itv);
1240
1241         if (itv->card->hw_all & IVTV_HW_CX25840) {
1242                 struct v4l2_control ctrl;
1243
1244                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1245                 ctrl.id = V4L2_CID_PRIVATE_BASE;
1246                 ctrl.value = itv->pvr150_workaround;
1247                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1248         }
1249
1250         vf.tuner = 0;
1251         vf.type = V4L2_TUNER_ANALOG_TV;
1252         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1253
1254         /* Set initial frequency. For PAL/SECAM broadcasts no
1255            'default' channel exists AFAIK. */
1256         if (itv->std == V4L2_STD_NTSC_M_JP) {
1257                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1258         }
1259         else if (itv->std & V4L2_STD_NTSC_M) {
1260                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1261         }
1262
1263         video_input = itv->active_input;
1264         itv->active_input++;    /* Force update of input */
1265         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1266
1267         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1268            in one place. */
1269         itv->std++;             /* Force full standard initialization */
1270         itv->std_out = itv->std;
1271         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1272
1273         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1274                 ivtv_init_mpeg_decoder(itv);
1275         }
1276         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1277
1278         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1279         if (!itv->has_cx23415)
1280                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1281
1282         /* Default interrupts enabled. For the PVR350 this includes the
1283            decoder VSYNC interrupt, which is always on. It is not only used
1284            during decoding but also by the OSD.
1285            Some old PVR250 cards had a cx23415, so testing for that is too
1286            general. Instead test if the card has video output capability. */
1287         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1288                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1289                 ivtv_set_osd_alpha(itv);
1290         }
1291         else
1292                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1293         return 0;
1294 }
1295
1296 static void ivtv_remove(struct pci_dev *pci_dev)
1297 {
1298         struct ivtv *itv = pci_get_drvdata(pci_dev);
1299
1300         IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1301
1302         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1303                 /* Stop all captures */
1304                 IVTV_DEBUG_INFO("Stopping all streams\n");
1305                 if (atomic_read(&itv->capturing) > 0)
1306                         ivtv_stop_all_captures(itv);
1307
1308                 /* Stop all decoding */
1309                 IVTV_DEBUG_INFO("Stopping decoding\n");
1310                 if (atomic_read(&itv->decoding) > 0) {
1311                         int type;
1312
1313                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1314                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1315                         else
1316                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1317                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1318                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1319                 }
1320                 ivtv_halt_firmware(itv);
1321         }
1322
1323         /* Interrupts */
1324         ivtv_set_irq_mask(itv, 0xffffffff);
1325         del_timer_sync(&itv->dma_timer);
1326
1327         /* Stop all Work Queues */
1328         flush_workqueue(itv->irq_work_queues);
1329         destroy_workqueue(itv->irq_work_queues);
1330
1331         ivtv_streams_cleanup(itv);
1332         ivtv_udma_free(itv);
1333
1334         exit_ivtv_i2c(itv);
1335
1336         free_irq(itv->dev->irq, (void *)itv);
1337         ivtv_iounmap(itv);
1338
1339         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1340         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1341         if (itv->has_cx23415)
1342                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1343
1344         pci_disable_device(itv->dev);
1345
1346         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1347 }
1348
1349 /* define a pci_driver for card detection */
1350 static struct pci_driver ivtv_pci_driver = {
1351       .name =     "ivtv",
1352       .id_table = ivtv_pci_tbl,
1353       .probe =    ivtv_probe,
1354       .remove =   ivtv_remove,
1355 };
1356
1357 static int module_start(void)
1358 {
1359         printk(KERN_INFO "ivtv:  Start initialization, version %s\n", IVTV_VERSION);
1360
1361         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1362
1363         /* Validate parameters */
1364         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1365                 printk(KERN_ERR "ivtv:  Exiting, ivtv_first_minor must be between 0 and %d\n",
1366                      IVTV_MAX_CARDS - 1);
1367                 return -1;
1368         }
1369
1370         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1371                 ivtv_debug = 0;
1372                 printk(KERN_INFO "ivtv:  Debug value must be >= 0 and <= 2047\n");
1373         }
1374
1375         if (pci_register_driver(&ivtv_pci_driver)) {
1376                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1377                 return -ENODEV;
1378         }
1379         printk(KERN_INFO "ivtv:  End initialization\n");
1380         return 0;
1381 }
1382
1383 static void module_cleanup(void)
1384 {
1385         int i, j;
1386
1387         pci_unregister_driver(&ivtv_pci_driver);
1388
1389         spin_lock(&ivtv_cards_lock);
1390         for (i = 0; i < ivtv_cards_active; i++) {
1391                 if (ivtv_cards[i] == NULL)
1392                         continue;
1393                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1394                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1395                 }
1396                 kfree(ivtv_cards[i]);
1397         }
1398         spin_unlock(&ivtv_cards_lock);
1399 }
1400
1401 /* Note: These symbols are exported because they are used by the ivtvfb
1402    framebuffer module and an infrared module for the IR-blaster. */
1403 EXPORT_SYMBOL(ivtv_set_irq_mask);
1404 EXPORT_SYMBOL(ivtv_cards_active);
1405 EXPORT_SYMBOL(ivtv_cards);
1406 EXPORT_SYMBOL(ivtv_cards_lock);
1407 EXPORT_SYMBOL(ivtv_api);
1408 EXPORT_SYMBOL(ivtv_vapi);
1409 EXPORT_SYMBOL(ivtv_vapi_result);
1410 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1411 EXPORT_SYMBOL(ivtv_debug);
1412 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1413 EXPORT_SYMBOL(ivtv_udma_setup);
1414 EXPORT_SYMBOL(ivtv_udma_unmap);
1415 EXPORT_SYMBOL(ivtv_udma_alloc);
1416 EXPORT_SYMBOL(ivtv_udma_prepare);
1417 EXPORT_SYMBOL(ivtv_init_on_first_open);
1418
1419 module_init(module_start);
1420 module_exit(module_cleanup);