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

   1 /*
   2     ivtv driver initialization and card probing
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* Main Driver file for the ivtv project:
  23  * Driver for the Conexant CX23415/CX23416 chip.
  24  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  25  * License: GPL
  26  * http://www.ivtvdriver.org
  27  *
  28  * -----
  29  * MPG600/MPG160 support by  T.Adachi <tadachi@tadachi-net.com>
  30  *                      and Takeru KOMORIYA<komoriya@paken.org>
  31  *
  32  * AVerMedia M179 GPIO info by Chris Pinkham <cpinkham@bc2va.org>
  33  *                using information provided by Jiun-Kuei Jung @ AVerMedia.
  34  *
  35  * Kurouto Sikou CX23416GYC-STVLP tested by K.Ohta <alpha292@bremen.or.jp>
  36  *                using information from T.Adachi,Takeru KOMORIYA and others :-)
  37  *
  38  * Nagase TRANSGEAR 5000TV, Aopen VA2000MAX-STN6 and I/O data GV-MVP/RX
  39  *                version by T.Adachi. Special thanks  Mr.Suzuki
  40  */
  41
  42 #include "ivtv-driver.h"
  43 #include "ivtv-version.h"
  44 #include "ivtv-fileops.h"
  45 #include "ivtv-i2c.h"
  46 #include "ivtv-firmware.h"
  47 #include "ivtv-queue.h"
  48 #include "ivtv-udma.h"
  49 #include "ivtv-irq.h"
  50 #include "ivtv-mailbox.h"
  51 #include "ivtv-streams.h"
  52 #include "ivtv-ioctl.h"
  53 #include "ivtv-cards.h"
  54 #include "ivtv-vbi.h"
  55 #include "ivtv-routing.h"
  56 #include "ivtv-gpio.h"
  57
  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 #ifdef MODULE
 857 static u32 ivtv_request_module(struct ivtv *itv, u32 hw,
 858                 const char *name, u32 id)
 859 {
 860         if ((hw & id) == 0)
 861                 return hw;
 862         if (request_module(name) != 0) {
 863                 IVTV_ERR("Failed to load module %s\n", name);
 864                 return hw & ~id;
 865         }
 866         IVTV_DEBUG_INFO("Loaded module %s\n", name);
 867         return hw;
 868 }
 869 #endif
 870
 871 static void ivtv_load_and_init_modules(struct ivtv *itv)
 872 {
 873         u32 hw = itv->card->hw_all;
 874         unsigned i;
 875
 876 #ifdef MODULE
 877         /* load modules */
 878 #ifndef CONFIG_MEDIA_TUNER
 879         hw = ivtv_request_module(itv, hw, "tuner", IVTV_HW_TUNER);
 880 #endif
 881 #ifndef CONFIG_VIDEO_CX25840
 882         hw = ivtv_request_module(itv, hw, "cx25840", IVTV_HW_CX25840);
 883 #endif
 884 #ifndef CONFIG_VIDEO_SAA711X
 885         hw = ivtv_request_module(itv, hw, "saa7115", IVTV_HW_SAA711X);
 886 #endif
 887 #ifndef CONFIG_VIDEO_SAA7127
 888         hw = ivtv_request_module(itv, hw, "saa7127", IVTV_HW_SAA7127);
 889 #endif
 890 #ifndef CONFIG_VIDEO_SAA717X
 891         hw = ivtv_request_module(itv, hw, "saa717x", IVTV_HW_SAA717X);
 892 #endif
 893 #ifndef CONFIG_VIDEO_UPD64031A
 894         hw = ivtv_request_module(itv, hw, "upd64031a", IVTV_HW_UPD64031A);
 895 #endif
 896 #ifndef CONFIG_VIDEO_UPD64083
 897         hw = ivtv_request_module(itv, hw, "upd64083", IVTV_HW_UPD6408X);
 898 #endif
 899 #ifndef CONFIG_VIDEO_MSP3400
 900         hw = ivtv_request_module(itv, hw, "msp3400", IVTV_HW_MSP34XX);
 901 #endif
 902 #ifndef CONFIG_VIDEO_VP27SMPX
 903         hw = ivtv_request_module(itv, hw, "vp27smpx", IVTV_HW_VP27SMPX);
 904 #endif
 905 #ifndef CONFIG_VIDEO_WM8775
 906         hw = ivtv_request_module(itv, hw, "wm8775", IVTV_HW_WM8775);
 907 #endif
 908 #ifndef CONFIG_VIDEO_WM8739
 909         hw = ivtv_request_module(itv, hw, "wm8739", IVTV_HW_WM8739);
 910 #endif
 911 #ifndef CONFIG_VIDEO_CS53L32A
 912         hw = ivtv_request_module(itv, hw, "cs53l32a", IVTV_HW_CS53L32A);
 913 #endif
 914 #ifndef CONFIG_VIDEO_M52790
 915         hw = ivtv_request_module(itv, hw, "m52790", IVTV_HW_M52790);
 916 #endif
 917 #endif
 918
 919         /* check which i2c devices are actually found */
 920         for (i = 0; i < 32; i++) {
 921                 u32 device = 1 << i;
 922
 923                 if (!(device & hw))
 924                         continue;
 925                 if (device == IVTV_HW_GPIO || device == IVTV_HW_TVEEPROM) {
 926                         /* GPIO and TVEEPROM do not use i2c probing */
 927                         itv->hw_flags |= device;
 928                         continue;
 929                 }
 930                 ivtv_i2c_register(itv, i);
 931                 if (ivtv_i2c_hw_addr(itv, device) > 0)
 932                         itv->hw_flags |= device;
 933         }
 934
 935         hw = itv->hw_flags;
 936
 937         if (itv->card->type == IVTV_CARD_CX23416GYC) {
 938                 /* Several variations of this card exist, detect which card
 939                    type should be used. */
 940                 if ((hw & (IVTV_HW_UPD64031A | IVTV_HW_UPD6408X)) == 0)
 941                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGRYCS);
 942                 else if ((hw & IVTV_HW_UPD64031A) == 0)
 943                         itv->card = ivtv_get_card(IVTV_CARD_CX23416GYC_NOGR);
 944         }
 945         else if (itv->card->type == IVTV_CARD_GV_MVPRX ||
 946                  itv->card->type == IVTV_CARD_GV_MVPRX2E) {
 947                 struct v4l2_crystal_freq crystal_freq;
 948
 949                 /* The crystal frequency of GVMVPRX is 24.576MHz */
 950                 crystal_freq.freq = SAA7115_FREQ_24_576_MHZ;
 951                 crystal_freq.flags = SAA7115_FREQ_FL_UCGC;
 952                 itv->video_dec_func(itv, VIDIOC_INT_S_CRYSTAL_FREQ, &crystal_freq);
 953         }
 954
 955         if (hw & IVTV_HW_CX25840) {
 956                 itv->vbi.raw_decoder_line_size = 1444;
 957                 itv->vbi.raw_decoder_sav_odd_field = 0x20;
 958                 itv->vbi.raw_decoder_sav_even_field = 0x60;
 959                 itv->vbi.sliced_decoder_line_size = 272;
 960                 itv->vbi.sliced_decoder_sav_odd_field = 0xB0;
 961                 itv->vbi.sliced_decoder_sav_even_field = 0xF0;
 962         }
 963
 964         if (hw & IVTV_HW_SAA711X) {
 965                 struct v4l2_chip_ident v = { V4L2_CHIP_MATCH_I2C_DRIVER, I2C_DRIVERID_SAA711X };
 966
 967                 /* determine the exact saa711x model */
 968                 itv->hw_flags &= ~IVTV_HW_SAA711X;
 969
 970                 ivtv_saa7115(itv, VIDIOC_G_CHIP_IDENT, &v);
 971                 if (v.ident == V4L2_IDENT_SAA7114) {
 972                         itv->hw_flags |= IVTV_HW_SAA7114;
 973                         /* VBI is not yet supported by the saa7114 driver. */
 974                         itv->v4l2_cap &= ~(V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_VBI_CAPTURE);
 975                 }
 976                 else {
 977                         itv->hw_flags |= IVTV_HW_SAA7115;
 978                 }
 979                 itv->vbi.raw_decoder_line_size = 1443;
 980                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 981                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 982                 itv->vbi.sliced_decoder_line_size = 51;
 983                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 984                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 985         }
 986
 987         if (hw & IVTV_HW_SAA717X) {
 988                 itv->vbi.raw_decoder_line_size = 1443;
 989                 itv->vbi.raw_decoder_sav_odd_field = 0x25;
 990                 itv->vbi.raw_decoder_sav_even_field = 0x62;
 991                 itv->vbi.sliced_decoder_line_size = 51;
 992                 itv->vbi.sliced_decoder_sav_odd_field = 0xAB;
 993                 itv->vbi.sliced_decoder_sav_even_field = 0xEC;
 994         }
 995 }
 996
 997 static int __devinit ivtv_probe(struct pci_dev *dev,
 998                                 const struct pci_device_id *pci_id)
 999 {
1000         int retval = 0;
1001         int vbi_buf_size;
1002         struct ivtv *itv;
1003
1004         spin_lock(&ivtv_cards_lock);
1005
1006         /* Make sure we've got a place for this card */
1007         if (ivtv_cards_active == IVTV_MAX_CARDS) {
1008                 printk(KERN_ERR "ivtv:  Maximum number of cards detected (%d)\n",
1009                               ivtv_cards_active);
1010                 spin_unlock(&ivtv_cards_lock);
1011                 return -ENOMEM;
1012         }
1013
1014         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
1015         if (itv == NULL) {
1016                 spin_unlock(&ivtv_cards_lock);
1017                 return -ENOMEM;
1018         }
1019         ivtv_cards[ivtv_cards_active] = itv;
1020         itv->dev = dev;
1021         itv->num = ivtv_cards_active++;
1022         snprintf(itv->name, sizeof(itv->name) - 1, "ivtv%d", itv->num);
1023         IVTV_INFO("Initializing card #%d\n", itv->num);
1024
1025         spin_unlock(&ivtv_cards_lock);
1026
1027         ivtv_process_options(itv);
1028         if (itv->options.cardtype == -1) {
1029                 retval = -ENODEV;
1030                 goto err;
1031         }
1032         if (ivtv_init_struct1(itv)) {
1033                 retval = -ENOMEM;
1034                 goto err;
1035         }
1036
1037         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
1038
1039         /* PCI Device Setup */
1040         if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
1041                 if (retval == -EIO)
1042                         goto free_workqueue;
1043                 else if (retval == -ENXIO)
1044                         goto free_mem;
1045         }
1046         /* save itv in the pci struct for later use */
1047         pci_set_drvdata(dev, itv);
1048
1049         /* map io memory */
1050         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1051                    itv->base_addr + IVTV_ENCODER_OFFSET, IVTV_ENCODER_SIZE);
1052         itv->enc_mem = ioremap_nocache(itv->base_addr + IVTV_ENCODER_OFFSET,
1053                                        IVTV_ENCODER_SIZE);
1054         if (!itv->enc_mem) {
1055                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1056                 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1057                 retval = -ENOMEM;
1058                 goto free_mem;
1059         }
1060
1061         if (itv->has_cx23415) {
1062                 IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1063                                 itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1064                 itv->dec_mem = ioremap_nocache(itv->base_addr + IVTV_DECODER_OFFSET,
1065                                 IVTV_DECODER_SIZE);
1066                 if (!itv->dec_mem) {
1067                         IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1068                         IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1069                         retval = -ENOMEM;
1070                         goto free_mem;
1071                 }
1072         }
1073         else {
1074                 itv->dec_mem = itv->enc_mem;
1075         }
1076
1077         /* map registers memory */
1078         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
1079                    itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1080         itv->reg_mem =
1081             ioremap_nocache(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1082         if (!itv->reg_mem) {
1083                 IVTV_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
1084                 IVTV_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
1085                 retval = -ENOMEM;
1086                 goto free_io;
1087         }
1088
1089         ivtv_gpio_init(itv);
1090
1091         /* active i2c  */
1092         IVTV_DEBUG_INFO("activating i2c...\n");
1093         if (init_ivtv_i2c(itv)) {
1094                 IVTV_ERR("Could not initialize i2c\n");
1095                 goto free_io;
1096         }
1097
1098         IVTV_DEBUG_INFO("Active card count: %d.\n", ivtv_cards_active);
1099
1100         if (itv->card->hw_all & IVTV_HW_TVEEPROM) {
1101                 /* Based on the model number the cardtype may be changed.
1102                    The PCI IDs are not always reliable. */
1103                 ivtv_process_eeprom(itv);
1104         }
1105         if (itv->card->comment)
1106                 IVTV_INFO("%s", itv->card->comment);
1107         if (itv->card->v4l2_capabilities == 0) {
1108                 /* card was detected but is not supported */
1109                 retval = -ENODEV;
1110                 goto free_i2c;
1111         }
1112
1113         if (itv->std == 0) {
1114                 itv->std = V4L2_STD_NTSC_M;
1115         }
1116
1117         if (itv->options.tuner == -1) {
1118                 int i;
1119
1120                 for (i = 0; i < IVTV_CARD_MAX_TUNERS; i++) {
1121                         if ((itv->std & itv->card->tuners[i].std) == 0)
1122                                 continue;
1123                         itv->options.tuner = itv->card->tuners[i].tuner;
1124                         break;
1125                 }
1126         }
1127         /* if no tuner was found, then pick the first tuner in the card list */
1128         if (itv->options.tuner == -1 && itv->card->tuners[0].std) {
1129                 itv->std = itv->card->tuners[0].std;
1130                 itv->options.tuner = itv->card->tuners[0].tuner;
1131         }
1132         if (itv->options.radio == -1)
1133                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1134
1135         /* The card is now fully identified, continue with card-specific
1136            initialization. */
1137         ivtv_init_struct2(itv);
1138
1139         ivtv_load_and_init_modules(itv);
1140
1141         if (itv->std & V4L2_STD_525_60) {
1142                 itv->is_60hz = 1;
1143                 itv->is_out_60hz = 1;
1144         } else {
1145                 itv->is_50hz = 1;
1146                 itv->is_out_50hz = 1;
1147         }
1148
1149         itv->yuv_info.osd_full_w = 720;
1150         itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1151         itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1152         itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1153
1154         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1155
1156         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1157         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1158         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1159         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1160         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1161
1162         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1163            It is possible to switch between PAL and NTSC, so we need to
1164            take the largest size here. */
1165         /* 1456 is multiple of 16, real size = 1444 */
1166         itv->vbi.raw_size = 1456;
1167         /* We use a buffer size of 1/2 of the total size needed for a
1168            frame. This is actually very useful, since we now receive
1169            a field at a time and that makes 'compressing' the raw data
1170            down to size by stripping off the SAV codes a lot easier.
1171            Note: having two different buffer sizes prevents standard
1172            switching on the fly. We need to find a better solution... */
1173         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1174         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1175         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1176
1177         if (itv->options.radio > 0)
1178                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1179
1180         if (itv->options.tuner > -1) {
1181                 struct tuner_setup setup;
1182
1183                 setup.addr = ADDR_UNSET;
1184                 setup.type = itv->options.tuner;
1185                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1186                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1187                         ivtv_reset_tuner_gpio : NULL;
1188                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1189                 if (setup.type == TUNER_XC2028) {
1190                         static struct xc2028_ctrl ctrl = {
1191                                 .fname = XC2028_DEFAULT_FIRMWARE,
1192                                 .max_len = 64,
1193                         };
1194                         struct v4l2_priv_tun_config cfg = {
1195                                 .tuner = itv->options.tuner,
1196                                 .priv = &ctrl,
1197                         };
1198                         ivtv_call_i2c_clients(itv, TUNER_SET_CONFIG, &cfg);
1199                 }
1200         }
1201
1202         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1203            are not. */
1204         itv->tuner_std = itv->std;
1205
1206         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1207                 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1208         }
1209
1210         /* clear interrupt mask, effectively disabling interrupts */
1211         ivtv_set_irq_mask(itv, 0xffffffff);
1212
1213         /* Register IRQ */
1214         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1215                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1216         if (retval) {
1217                 IVTV_ERR("Failed to register irq %d\n", retval);
1218                 goto free_i2c;
1219         }
1220
1221         retval = ivtv_streams_setup(itv);
1222         if (retval) {
1223                 IVTV_ERR("Error %d setting up streams\n", retval);
1224                 goto free_irq;
1225         }
1226         retval = ivtv_streams_register(itv);
1227         if (retval) {
1228                 IVTV_ERR("Error %d registering devices\n", retval);
1229                 goto free_streams;
1230         }
1231         IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1232         return 0;
1233
1234 free_streams:
1235         ivtv_streams_cleanup(itv, 1);
1236 free_irq:
1237         free_irq(itv->dev->irq, (void *)itv);
1238 free_i2c:
1239         exit_ivtv_i2c(itv);
1240 free_io:
1241         ivtv_iounmap(itv);
1242 free_mem:
1243         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1244         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1245         if (itv->has_cx23415)
1246                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1247 free_workqueue:
1248         destroy_workqueue(itv->irq_work_queues);
1249 err:
1250         if (retval == 0)
1251                 retval = -ENODEV;
1252         IVTV_ERR("Error %d on initialization\n", retval);
1253
1254         spin_lock(&ivtv_cards_lock);
1255         kfree(ivtv_cards[ivtv_cards_active]);
1256         ivtv_cards[ivtv_cards_active] = NULL;
1257         spin_unlock(&ivtv_cards_lock);
1258         return retval;
1259 }
1260
1261 int ivtv_init_on_first_open(struct ivtv *itv)
1262 {
1263         struct v4l2_frequency vf;
1264         int fw_retry_count = 3;
1265         int video_input;
1266
1267         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1268                 return -ENXIO;
1269
1270         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1271                 return 0;
1272
1273         while (--fw_retry_count > 0) {
1274                 /* load firmware */
1275                 if (ivtv_firmware_init(itv) == 0)
1276                         break;
1277                 if (fw_retry_count > 1)
1278                         IVTV_WARN("Retry loading firmware\n");
1279         }
1280
1281         if (fw_retry_count == 0) {
1282                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1283                 return -ENXIO;
1284         }
1285
1286         /* Try and get firmware versions */
1287         IVTV_DEBUG_INFO("Getting firmware version..\n");
1288         ivtv_firmware_versions(itv);
1289
1290         if (itv->card->hw_all & IVTV_HW_CX25840) {
1291                 struct v4l2_control ctrl;
1292
1293                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1294                 ctrl.id = V4L2_CID_PRIVATE_BASE;
1295                 ctrl.value = itv->pvr150_workaround;
1296                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1297         }
1298
1299         vf.tuner = 0;
1300         vf.type = V4L2_TUNER_ANALOG_TV;
1301         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1302
1303         /* Set initial frequency. For PAL/SECAM broadcasts no
1304            'default' channel exists AFAIK. */
1305         if (itv->std == V4L2_STD_NTSC_M_JP) {
1306                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1307         }
1308         else if (itv->std & V4L2_STD_NTSC_M) {
1309                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1310         }
1311
1312         video_input = itv->active_input;
1313         itv->active_input++;    /* Force update of input */
1314         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_INPUT, &video_input);
1315
1316         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1317            in one place. */
1318         itv->std++;             /* Force full standard initialization */
1319         itv->std_out = itv->std;
1320         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_FREQUENCY, &vf);
1321
1322         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1323                 ivtv_init_mpeg_decoder(itv);
1324         }
1325         ivtv_v4l2_ioctls(itv, NULL, VIDIOC_S_STD, &itv->tuner_std);
1326
1327         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1328         if (!itv->has_cx23415)
1329                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1330
1331         /* Default interrupts enabled. For the PVR350 this includes the
1332            decoder VSYNC interrupt, which is always on. It is not only used
1333            during decoding but also by the OSD.
1334            Some old PVR250 cards had a cx23415, so testing for that is too
1335            general. Instead test if the card has video output capability. */
1336         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1337                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1338                 ivtv_set_osd_alpha(itv);
1339         }
1340         else
1341                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1342         return 0;
1343 }
1344
1345 static void ivtv_remove(struct pci_dev *pci_dev)
1346 {
1347         struct ivtv *itv = pci_get_drvdata(pci_dev);
1348
1349         IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1350
1351         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1352                 /* Stop all captures */
1353                 IVTV_DEBUG_INFO("Stopping all streams\n");
1354                 if (atomic_read(&itv->capturing) > 0)
1355                         ivtv_stop_all_captures(itv);
1356
1357                 /* Stop all decoding */
1358                 IVTV_DEBUG_INFO("Stopping decoding\n");
1359                 if (atomic_read(&itv->decoding) > 0) {
1360                         int type;
1361
1362                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1363                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1364                         else
1365                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1366                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1367                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1368                 }
1369                 ivtv_halt_firmware(itv);
1370         }
1371
1372         /* Interrupts */
1373         ivtv_set_irq_mask(itv, 0xffffffff);
1374         del_timer_sync(&itv->dma_timer);
1375
1376         /* Stop all Work Queues */
1377         flush_workqueue(itv->irq_work_queues);
1378         destroy_workqueue(itv->irq_work_queues);
1379
1380         ivtv_streams_cleanup(itv, 1);
1381         ivtv_udma_free(itv);
1382
1383         exit_ivtv_i2c(itv);
1384
1385         free_irq(itv->dev->irq, (void *)itv);
1386         ivtv_iounmap(itv);
1387
1388         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1389         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1390         if (itv->has_cx23415)
1391                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1392
1393         pci_disable_device(itv->dev);
1394
1395         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1396 }
1397
1398 /* define a pci_driver for card detection */
1399 static struct pci_driver ivtv_pci_driver = {
1400       .name =     "ivtv",
1401       .id_table = ivtv_pci_tbl,
1402       .probe =    ivtv_probe,
1403       .remove =   ivtv_remove,
1404 };
1405
1406 static int module_start(void)
1407 {
1408         printk(KERN_INFO "ivtv:  Start initialization, version %s\n", IVTV_VERSION);
1409
1410         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1411
1412         /* Validate parameters */
1413         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1414                 printk(KERN_ERR "ivtv:  Exiting, ivtv_first_minor must be between 0 and %d\n",
1415                      IVTV_MAX_CARDS - 1);
1416                 return -1;
1417         }
1418
1419         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1420                 ivtv_debug = 0;
1421                 printk(KERN_INFO "ivtv:  Debug value must be >= 0 and <= 2047\n");
1422         }
1423
1424         if (pci_register_driver(&ivtv_pci_driver)) {
1425                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1426                 return -ENODEV;
1427         }
1428         printk(KERN_INFO "ivtv:  End initialization\n");
1429         return 0;
1430 }
1431
1432 static void module_cleanup(void)
1433 {
1434         int i, j;
1435
1436         pci_unregister_driver(&ivtv_pci_driver);
1437
1438         spin_lock(&ivtv_cards_lock);
1439         for (i = 0; i < ivtv_cards_active; i++) {
1440                 if (ivtv_cards[i] == NULL)
1441                         continue;
1442                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1443                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1444                 }
1445                 kfree(ivtv_cards[i]);
1446         }
1447         spin_unlock(&ivtv_cards_lock);
1448 }
1449
1450 /* Note: These symbols are exported because they are used by the ivtvfb
1451    framebuffer module and an infrared module for the IR-blaster. */
1452 EXPORT_SYMBOL(ivtv_set_irq_mask);
1453 EXPORT_SYMBOL(ivtv_cards_active);
1454 EXPORT_SYMBOL(ivtv_cards);
1455 EXPORT_SYMBOL(ivtv_cards_lock);
1456 EXPORT_SYMBOL(ivtv_api);
1457 EXPORT_SYMBOL(ivtv_vapi);
1458 EXPORT_SYMBOL(ivtv_vapi_result);
1459 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1460 EXPORT_SYMBOL(ivtv_debug);
1461 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1462 EXPORT_SYMBOL(ivtv_udma_setup);
1463 EXPORT_SYMBOL(ivtv_udma_unmap);
1464 EXPORT_SYMBOL(ivtv_udma_alloc);
1465 EXPORT_SYMBOL(ivtv_udma_prepare);
1466 EXPORT_SYMBOL(ivtv_init_on_first_open);
1467
1468 module_init(module_start);
1469 module_exit(module_cleanup);