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