SAFE public projects git trees. - safe/jmp/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         mutex_lock(&itv->serialize_lock);
1007
1008         /* PCI Device Setup */
1009         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
1010                 if (retval == -EIO)
1011                         goto free_workqueue;
1012                 else if (retval == -ENXIO)
1013                         goto free_mem;
1014         }
1015         /* save itv in the pci struct for later use */
1016         pci_set_drvdata(dev, itv);
1017
1018         /* map io memory */
1019         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1020                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1021         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1022                                        IVTV_ENCODER_SIZE);
1023         if (!itv->enc_mem) {
1024                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1025                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1026                 retval = -ENOMEM;
1027                 goto free_mem;
1028         }
1029
1030         if (itv->has_cx23415) {
1031                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1032                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1033                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1034                                 IVTV_DECODER_SIZE);
1035                 if (!itv->dec_mem) {
1036                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1037                         IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1038                         retval = -ENOMEM;
1039                         goto free_mem;
1040                 }
1041         }
1042         else {
1043                 itv->dec_mem = itv->enc_mem;
1044         }
1045
1046         /* map registers memory */
1047         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1048                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1049         itv->reg_mem =
1050             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1051         if (!itv->reg_mem) {
1052                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1053                 IVTV_ERR("or disabling CONFIG_HIMEM4G into the kernel would help\n");
1054                 retval = -ENOMEM;
1055                 goto free_io;
1056         }
1057
1058         /* Check yuv output filter table */
1059         if (itv->has_cx23415) ivtv_yuv_filter_check(itv);
1060
1061         ivtv_gpio_init(itv);
1062
1063         /* active i2c  */
1064         IVTV_DEBUG_INFO("activating i2c...\n");
1065         if (init_ivtv_i2c(itv)) {
1066                 IVTV_ERR("Could not initialize i2c\n");
1067                 goto free_irq;
1068         }
1069
1070         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1071
1072         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1073 #ifdef CONFIG_VIDEO_TVEEPROM_MODULE
1074                 ivtv_request_module(itv, "tveeprom");
1075 #endif
1076                 /* Based on the model number the cardtype may be changed.
1077                    The PCI IDs are not always reliable. */
1078                 ivtv_process_eeprom(itv);
1079         }
1080
1081         if (itv->std == 0) {
1082                 itv->std = V4L2_STD_NTSC_M;
1083         }
1084
1085         if (itv->options.tuner == -1) {
1086                 int i;
1087
1088                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1089                         if ((itv->std & itv->card->tuners[i].std) == 0)
1090                                 continue;
1091                         itv->options.tuner = itv->card->tuners[i].tuner;
1092                         break;
1093                 }
1094         }
1095         /* if no tuner was found, then pick the first tuner in the card list */
1096         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1097                 itv->std = itv->card->tuners[0].std;
1098                 itv->options.tuner = itv->card->tuners[0].tuner;
1099         }
1100         if (itv->options.radio == -1)
1101                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1102
1103         /* The card is now fully identified, continue with card-specific
1104            initialization. */
1105         ivtv_init_struct2(itv);
1106
1107         ivtv_load_and_init_modules(itv);
1108
1109         if (itv->std & V4L2_STD_525_60) {
1110                 itv->is_60hz = 1;
1111                 itv->is_out_60hz = 1;
1112         } else {
1113                 itv->is_50hz = 1;
1114                 itv->is_out_50hz = 1;
1115         }
1116         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1117
1118         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1119         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1120         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1121
1122         /* 0x15180 == 720 * 480 / 4, 0x19500 == 720 * 576 / 4 */
1123         yuv_buf_size = itv->is_60hz ? 0x15180 : 0x19500;
1124         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = yuv_buf_size / 2;
1125         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = yuv_buf_size / 8;
1126
1127         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1128            It is possible to switch between PAL and NTSC, so we need to
1129            take the largest size here. */
1130         /* 1456 is multiple of 16, real size = 1444 */
1131         itv->vbi.raw_size = 1456;
1132         /* We use a buffer size of 1/2 of the total size needed for a
1133            frame. This is actually very useful, since we now receive
1134            a field at a time and that makes 'compressing' the raw data
1135            down to size by stripping off the SAV codes a lot easier.
1136            Note: having two different buffer sizes prevents standard
1137            switching on the fly. We need to find a better solution... */
1138         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1139         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1140         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1141
1142         if (itv->options.radio > 0)
1143                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1144
1145         if (itv->options.tuner > -1 && itv->tunerid == 0) {
1146                 struct tuner_setup setup;
1147
1148                 setup.addr = ADDR_UNSET;
1149                 setup.type = itv->options.tuner;
1150                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1151                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1152         }
1153
1154         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1155            are not. */
1156         itv->tuner_std = itv->std;
1157
1158         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1159                 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1160         }
1161
1162         retval = ivtv_streams_setup(itv);
1163         if (retval) {
1164                 IVTV_ERR("Error %d setting up streams\n", retval);
1165                 goto free_i2c;
1166         }
1167
1168         IVTV_DEBUG_IRQ("Masking interrupts\n");
1169         /* clear interrupt mask, effectively disabling interrupts */
1170         ivtv_set_irq_mask(itv, 0xffffffff);
1171
1172         /* Register IRQ */
1173         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1174                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1175         if (retval) {
1176                 IVTV_ERR("Failed to register irq %d\n", retval);
1177                 goto free_streams;
1178         }
1179         mutex_unlock(&itv->serialize_lock);
1180         IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1181         return 0;
1182
1183       free_irq:
1184         free_irq(itv->dev->irq, (void *)itv);
1185       free_streams:
1186         ivtv_streams_cleanup(itv);
1187       free_i2c:
1188         exit_ivtv_i2c(itv);
1189       free_io:
1190         ivtv_iounmap(itv);
1191       free_mem:
1192         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1193         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1194         if (itv->has_cx23415)
1195                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1196       free_workqueue:
1197         destroy_workqueue(itv->irq_work_queues);
1198         mutex_unlock(&itv->serialize_lock);
1199       err:
1200         if (retval == 0)
1201                 retval = -ENODEV;
1202         IVTV_ERR("Error %d on initialization\n", retval);
1203
1204         spin_lock(&ivtv_cards_lock);
1205         kfree(ivtv_cards[ivtv_cards_active]);
1206         ivtv_cards[ivtv_cards_active] = NULL;
1207         spin_unlock(&ivtv_cards_lock);
1208         return retval;
1209 }
1210
1211 int ivtv_init_on_first_open(struct ivtv *itv)
1212 {
1213         struct v4l2_frequency vf;
1214         int fw_retry_count = 3;
1215         int video_input;
1216
1217         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1218                 return -ENXIO;
1219
1220         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1221                 return 0;
1222
1223         while (--fw_retry_count > 0) {
1224                 /* load firmware */
1225                 if (ivtv_firmware_init(itv) == 0)
1226                         break;
1227                 if (fw_retry_count > 1)
1228                         IVTV_WARN("Retry loading firmware\n");
1229         }
1230
1231         if (fw_retry_count == 0) {
1232                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1233                 return -ENXIO;
1234         }
1235
1236         /* Try and get firmware versions */
1237         IVTV_DEBUG_INFO("Getting firmware version..\n");
1238         ivtv_firmware_versions(itv);
1239
1240         if (itv->card->hw_all & IVTV_HW_CX25840) {
1241                 struct v4l2_control ctrl;
1242
1243                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1244                 ctrl.id = V4L2_CID_PRIVATE_BASE;
1245                 ctrl.value = itv->pvr150_workaround;
1246                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1247         }
1248
1249         vf.tuner = 0;
1250         vf.type = V4L2_TUNER_ANALOG_TV;
1251         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1252
1253         /* Set initial frequency. For PAL/SECAM broadcasts no
1254            'default' channel exists AFAIK. */
1255         if (itv->std == V4L2_STD_NTSC_M_JP) {
1256                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1257         }
1258         else if (itv->std & V4L2_STD_NTSC_M) {
1259                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1260         }
1261
1262         video_input = itv->active_input;
1263         itv->active_input++;    /* Force update of input */
1264         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1265
1266         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1267            in one place. */
1268         itv->std++;             /* Force full standard initialization */
1269         itv->std_out = itv->std;
1270         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1271
1272         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1273                 ivtv_init_mpeg_decoder(itv);
1274         }
1275         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1276
1277         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1278         if (!itv->has_cx23415)
1279                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1280
1281         /* Default interrupts enabled. For the PVR350 this includes the
1282            decoder VSYNC interrupt, which is always on. It is not only used
1283            during decoding but also by the OSD.
1284            Some old PVR250 cards had a cx23415, so testing for that is too
1285            general. Instead test if the card has video output capability. */
1286         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1287                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1288                 ivtv_set_osd_alpha(itv);
1289         }
1290         else
1291                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1292         return 0;
1293 }
1294
1295 static void ivtv_remove(struct pci_dev *pci_dev)
1296 {
1297         struct ivtv *itv = pci_get_drvdata(pci_dev);
1298
1299         IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1300
1301         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1302                 /* Stop all captures */
1303                 IVTV_DEBUG_INFO("Stopping all streams\n");
1304                 if (atomic_read(&itv->capturing) > 0)
1305                         ivtv_stop_all_captures(itv);
1306
1307                 /* Stop all decoding */
1308                 IVTV_DEBUG_INFO("Stopping decoding\n");
1309                 if (atomic_read(&itv->decoding) > 0) {
1310                         int type;
1311
1312                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1313                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1314                         else
1315                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1316                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1317                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1318                 }
1319                 ivtv_halt_firmware(itv);
1320         }
1321
1322         /* Interrupts */
1323         ivtv_set_irq_mask(itv, 0xffffffff);
1324         del_timer_sync(&itv->dma_timer);
1325
1326         /* Stop all Work Queues */
1327         flush_workqueue(itv->irq_work_queues);
1328         destroy_workqueue(itv->irq_work_queues);
1329
1330         ivtv_streams_cleanup(itv);
1331         ivtv_udma_free(itv);
1332
1333         exit_ivtv_i2c(itv);
1334
1335         free_irq(itv->dev->irq, (void *)itv);
1336         ivtv_iounmap(itv);
1337
1338         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1339         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1340         if (itv->has_cx23415)
1341                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1342
1343         pci_disable_device(itv->dev);
1344
1345         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1346 }
1347
1348 /* define a pci_driver for card detection */
1349 static struct pci_driver ivtv_pci_driver = {
1350       .name =     "ivtv",
1351       .id_table = ivtv_pci_tbl,
1352       .probe =    ivtv_probe,
1353       .remove =   ivtv_remove,
1354 };
1355
1356 static int module_start(void)
1357 {
1358         printk(KERN_INFO "ivtv:  Start initialization, version %s\n", IVTV_VERSION);
1359
1360         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1361
1362         /* Validate parameters */
1363         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1364                 printk(KERN_ERR "ivtv:  Exiting, ivtv_first_minor must be between 0 and %d\n",
1365                      IVTV_MAX_CARDS - 1);
1366                 return -1;
1367         }
1368
1369         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1370                 ivtv_debug = 0;
1371                 printk(KERN_INFO "ivtv:  Debug value must be >= 0 and <= 2047\n");
1372         }
1373
1374         if (pci_register_driver(&ivtv_pci_driver)) {
1375                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1376                 return -ENODEV;
1377         }
1378         printk(KERN_INFO "ivtv:  End initialization\n");
1379         return 0;
1380 }
1381
1382 static void module_cleanup(void)
1383 {
1384         int i, j;
1385
1386         pci_unregister_driver(&ivtv_pci_driver);
1387
1388         spin_lock(&ivtv_cards_lock);
1389         for (i = 0; i < ivtv_cards_active; i++) {
1390                 if (ivtv_cards[i] == NULL)
1391                         continue;
1392                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1393                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1394                 }
1395                 kfree(ivtv_cards[i]);
1396         }
1397         spin_unlock(&ivtv_cards_lock);
1398 }
1399
1400 /* Note: These symbols are exported because they are used by the ivtvfb
1401    framebuffer module and an infrared module for the IR-blaster. */
1402 EXPORT_SYMBOL(ivtv_set_irq_mask);
1403 EXPORT_SYMBOL(ivtv_cards_active);
1404 EXPORT_SYMBOL(ivtv_cards);
1405 EXPORT_SYMBOL(ivtv_cards_lock);
1406 EXPORT_SYMBOL(ivtv_api);
1407 EXPORT_SYMBOL(ivtv_vapi);
1408 EXPORT_SYMBOL(ivtv_vapi_result);
1409 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1410 EXPORT_SYMBOL(ivtv_debug);
1411 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1412 EXPORT_SYMBOL(ivtv_udma_setup);
1413 EXPORT_SYMBOL(ivtv_udma_unmap);
1414 EXPORT_SYMBOL(ivtv_udma_alloc);
1415 EXPORT_SYMBOL(ivtv_udma_prepare);
1416 EXPORT_SYMBOL(ivtv_init_on_first_open);
1417
1418 module_init(module_start);
1419 module_exit(module_cleanup);