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