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