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\t26 = Buffalo PC-MV5L/PCI\n"
 195                  "\t\t\t 0 = Autodetect (default)\n"
 196                  "\t\t\t-1 = Ignore this card\n\t\t");
 197 MODULE_PARM_DESC(pal, "Set PAL standard: BGH, DK, I, M, N, Nc, 60");
 198 MODULE_PARM_DESC(secam, "Set SECAM standard: BGH, DK, L, LC");
 199 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J (Japan), K (South Korea)");
 200 MODULE_PARM_DESC(tunertype,
 201                 "Specify tuner type:\n"
 202                 "\t\t\t 0 = tuner for PAL-B/G/H/D/K/I, SECAM-B/G/H/D/K/L/Lc\n"
 203                 "\t\t\t 1 = tuner for NTSC-M/J/K, PAL-M/N/Nc\n"
 204                 "\t\t\t-1 = Autodetect (default)\n");
 205 MODULE_PARM_DESC(debug,
 206                  "Debug level (bitmask). Default: 0\n"
 207                  "\t\t\t   1/0x0001: warning\n"
 208                  "\t\t\t   2/0x0002: info\n"
 209                  "\t\t\t   4/0x0004: mailbox\n"
 210                  "\t\t\t   8/0x0008: ioctl\n"
 211                  "\t\t\t  16/0x0010: file\n"
 212                  "\t\t\t  32/0x0020: dma\n"
 213                  "\t\t\t  64/0x0040: irq\n"
 214                  "\t\t\t 128/0x0080: decoder\n"
 215                  "\t\t\t 256/0x0100: yuv\n"
 216                  "\t\t\t 512/0x0200: i2c\n"
 217                  "\t\t\t1024/0x0400: high volume\n");
 218 MODULE_PARM_DESC(ivtv_pci_latency,
 219                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 220                  "\t\t\tDefault: Yes");
 221 MODULE_PARM_DESC(ivtv_yuv_mode,
 222                  "Specify the yuv playback mode:\n"
 223                  "\t\t\t0 = interlaced\n\t\t\t1 = progressive\n\t\t\t2 = auto\n"
 224                  "\t\t\tDefault: 0 (interlaced)");
 225 MODULE_PARM_DESC(ivtv_yuv_threshold,
 226                  "If ivtv_yuv_mode is 2 (auto) then playback content as\n\t\tprogressive if src height <= ivtv_yuvthreshold\n"
 227                  "\t\t\tDefault: 480");;
 228 MODULE_PARM_DESC(enc_mpg_buffers,
 229                  "Encoder MPG Buffers (in MB)\n"
 230                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_MPG_BUFFERS));
 231 MODULE_PARM_DESC(enc_yuv_buffers,
 232                  "Encoder YUV Buffers (in MB)\n"
 233                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_YUV_BUFFERS));
 234 MODULE_PARM_DESC(enc_vbi_buffers,
 235                  "Encoder VBI Buffers (in MB)\n"
 236                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_VBI_BUFFERS));
 237 MODULE_PARM_DESC(enc_pcm_buffers,
 238                  "Encoder PCM buffers (in kB)\n"
 239                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_ENC_PCM_BUFFERS));
 240 MODULE_PARM_DESC(dec_mpg_buffers,
 241                  "Decoder MPG buffers (in MB)\n"
 242                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_MPG_BUFFERS));
 243 MODULE_PARM_DESC(dec_yuv_buffers,
 244                  "Decoder YUV buffers (in MB)\n"
 245                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_YUV_BUFFERS));
 246 MODULE_PARM_DESC(dec_vbi_buffers,
 247                  "Decoder VBI buffers (in kB)\n"
 248                  "\t\t\tDefault: " __stringify(IVTV_DEFAULT_DEC_VBI_BUFFERS));
 249 MODULE_PARM_DESC(newi2c,
 250                  "Use new I2C implementation\n"
 251                  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
 252                  "\t\t\tDefault is autodetect");
 253
 254 MODULE_PARM_DESC(ivtv_first_minor, "Set minor assigned to first card");
 255
 256 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 257 MODULE_DESCRIPTION("CX23415/CX23416 driver");
 258 MODULE_SUPPORTED_DEVICE
 259     ("CX23415/CX23416 MPEG2 encoder (WinTV PVR-150/250/350/500,\n"
 260                 "\t\t\tYuan MPG series and similar)");
 261 MODULE_LICENSE("GPL");
 262
 263 MODULE_VERSION(IVTV_VERSION);
 264
 265 void ivtv_clear_irq_mask(struct ivtv *itv, u32 mask)
 266 {
 267         itv->irqmask &= ~mask;
 268         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 269 }
 270
 271 void ivtv_set_irq_mask(struct ivtv *itv, u32 mask)
 272 {
 273         itv->irqmask |= mask;
 274         write_reg_sync(itv->irqmask, IVTV_REG_IRQMASK);
 275 }
 276
 277 int ivtv_set_output_mode(struct ivtv *itv, int mode)
 278 {
 279     int old_mode;
 280
 281     spin_lock(&itv->lock);
 282     old_mode = itv->output_mode;
 283     if (old_mode == 0)
 284         itv->output_mode = old_mode = mode;
 285     spin_unlock(&itv->lock);
 286     return old_mode;
 287 }
 288
 289 struct ivtv_stream *ivtv_get_output_stream(struct ivtv *itv)
 290 {
 291         switch (itv->output_mode) {
 292         case OUT_MPG:
 293                 return &itv->streams[IVTV_DEC_STREAM_TYPE_MPG];
 294         case OUT_YUV:
 295                 return &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 296         default:
 297                 return NULL;
 298         }
 299 }
 300
 301 int ivtv_waitq(wait_queue_head_t *waitq)
 302 {
 303         DEFINE_WAIT(wait);
 304
 305         prepare_to_wait(waitq, &wait, TASK_INTERRUPTIBLE);
 306         schedule();
 307         finish_wait(waitq, &wait);
 308         return signal_pending(current) ? -EINTR : 0;
 309 }
 310
 311 /* Generic utility functions */
 312 int ivtv_msleep_timeout(unsigned int msecs, int intr)
 313 {
 314         int ret;
 315         int timeout = msecs_to_jiffies(msecs);
 316
 317         do {
 318                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 319                 timeout = schedule_timeout(timeout);
 320                 if (intr && (ret = signal_pending(current)))
 321                         return ret;
 322         } while (timeout);
 323         return 0;
 324 }
 325
 326 /* Release ioremapped memory */
 327 static void ivtv_iounmap(struct ivtv *itv)
 328 {
 329         if (itv == NULL)
 330                 return;
 331
 332         /* Release registers memory */
 333         if (itv->reg_mem != NULL) {
 334                 IVTV_DEBUG_INFO("releasing reg_mem\n");
 335                 iounmap(itv->reg_mem);
 336                 itv->reg_mem = NULL;
 337         }
 338         /* Release io memory */
 339         if (itv->has_cx23415 && itv->dec_mem != NULL) {
 340                 IVTV_DEBUG_INFO("releasing dec_mem\n");
 341                 iounmap(itv->dec_mem);
 342         }
 343         itv->dec_mem = NULL;
 344
 345         /* Release io memory */
 346         if (itv->enc_mem != NULL) {
 347                 IVTV_DEBUG_INFO("releasing enc_mem\n");
 348                 iounmap(itv->enc_mem);
 349                 itv->enc_mem = NULL;
 350         }
 351 }
 352
 353 /* Hauppauge card? get values from tveeprom */
 354 void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
 355 {
 356         u8 eedata[256];
 357
 358         itv->i2c_client.addr = 0xA0 >> 1;
 359         tveeprom_read(&itv->i2c_client, eedata, sizeof(eedata));
 360         tveeprom_hauppauge_analog(&itv->i2c_client, tv, eedata);
 361 }
 362
 363 static void ivtv_process_eeprom(struct ivtv *itv)
 364 {
 365         struct tveeprom tv;
 366         int pci_slot = PCI_SLOT(itv->dev->devfn);
 367
 368         ivtv_read_eeprom(itv, &tv);
 369
 370         /* Many thanks to Steven Toth from Hauppauge for providing the
 371            model numbers */
 372         switch (tv.model) {
 373                 /* In a few cases the PCI subsystem IDs do not correctly
 374                    identify the card. A better method is to check the
 375                    model number from the eeprom instead. */
 376                 case 30012 ... 30039:  /* Low profile PVR250 */
 377                 case 32000 ... 32999:
 378                 case 48000 ... 48099:  /* 48??? range are PVR250s with a cx23415 */
 379                 case 48400 ... 48599:
 380                         itv->card = ivtv_get_card(IVTV_CARD_PVR_250);
 381                         break;
 382                 case 48100 ... 48399:
 383                 case 48600 ... 48999:
 384                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350);
 385                         break;
 386                 case 23000 ... 23999:  /* PVR500 */
 387                 case 25000 ... 25999:  /* Low profile PVR150 */
 388                 case 26000 ... 26999:  /* Regular PVR150 */
 389                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 390                         break;
 391                 case 0:
 392                         IVTV_ERR("Invalid EEPROM\n");
 393                         return;
 394                 default:
 395                         IVTV_ERR("Unknown model %d, defaulting to PVR-150\n", tv.model);
 396                         itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
 397                         break;
 398         }
 399
 400         switch (tv.model) {
 401                 /* Old style PVR350 (with an saa7114) uses this input for
 402                    the tuner. */
 403                 case 48254:
 404                         itv->card = ivtv_get_card(IVTV_CARD_PVR_350_V1);
 405                         break;
 406                 default:
 407                         break;
 408         }
 409
 410         itv->v4l2_cap = itv->card->v4l2_capabilities;
 411         itv->card_name = itv->card->name;
 412         itv->card_i2c = itv->card->i2c;
 413
 414         /* If this is a PVR500 then it should be possible to detect whether it is the
 415            first or second unit by looking at the subsystem device ID: is bit 4 is
 416            set, then it is the second unit (according to info from Hauppauge).
 417
 418            However, while this works for most cards, I have seen a few PVR500 cards
 419            where both units have the same subsystem ID.
 420
 421            So instead I look at the reported 'PCI slot' (which is the slot on the PVR500
 422            PCI bridge) and if it is 8, then it is assumed to be the first unit, otherwise
 423            it is the second unit. It is possible that it is a different slot when ivtv is
 424            used in Xen, in that case I ignore this card here. The worst that can happen
 425            is that the card presents itself with a non-working radio device.
 426
 427            This detection is needed since the eeprom reports incorrectly that a radio is
 428            present on the second unit. */
 429         if (tv.model / 1000 == 23) {
 430                 static const struct ivtv_card_tuner_i2c ivtv_i2c_radio = {
 431                         .radio = { 0x60, I2C_CLIENT_END },
 432                         .demod = { 0x43, I2C_CLIENT_END },
 433                         .tv = { 0x61, I2C_CLIENT_END },
 434                 };
 435
 436                 itv->card_name = "WinTV PVR 500";
 437                 itv->card_i2c = &ivtv_i2c_radio;
 438                 if (pci_slot == 8 || pci_slot == 9) {
 439                         int is_first = (pci_slot & 1) == 0;
 440
 441                         itv->card_name = is_first ? "WinTV PVR 500 (unit #1)" :
 442                                                     "WinTV PVR 500 (unit #2)";
 443                         if (!is_first) {
 444                                 IVTV_INFO("Correcting tveeprom data: no radio present on second unit\n");
 445                                 tv.has_radio = 0;
 446                         }
 447                 }
 448         }
 449         IVTV_INFO("Autodetected %s\n", itv->card_name);
 450
 451         switch (tv.tuner_hauppauge_model) {
 452                 case 85:
 453                 case 99:
 454                 case 112:
 455                         itv->pvr150_workaround = 1;
 456                         break;
 457                 default:
 458                         break;
 459         }
 460         if (tv.tuner_type == TUNER_ABSENT)
 461                 IVTV_ERR("tveeprom cannot autodetect tuner!");
 462
 463         if (itv->options.tuner == -1)
 464                 itv->options.tuner = tv.tuner_type;
 465         if (itv->options.radio == -1)
 466                 itv->options.radio = (tv.has_radio != 0);
 467         /* only enable newi2c if an IR blaster is present */
 468         if (itv->options.newi2c == -1 && tv.has_ir) {
 469                 itv->options.newi2c = (tv.has_ir & 4) ? 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), "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                 if (itv->std & V4L2_STD_PAL)
1131                         itv->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
1132                 else if (itv->std & V4L2_STD_NTSC)
1133                         itv->std = V4L2_STD_NTSC_M;
1134                 else if (itv->std & V4L2_STD_SECAM)
1135                         itv->std = V4L2_STD_SECAM_L;
1136                 itv->options.tuner = itv->card->tuners[0].tuner;
1137         }
1138         if (itv->options.radio == -1)
1139                 itv->options.radio = (itv->card->radio_input.audio_type != 0);
1140
1141         /* The card is now fully identified, continue with card-specific
1142            initialization. */
1143         ivtv_init_struct2(itv);
1144
1145         ivtv_load_and_init_modules(itv);
1146
1147         if (itv->std & V4L2_STD_525_60) {
1148                 itv->is_60hz = 1;
1149                 itv->is_out_60hz = 1;
1150         } else {
1151                 itv->is_50hz = 1;
1152                 itv->is_out_50hz = 1;
1153         }
1154
1155         itv->yuv_info.osd_full_w = 720;
1156         itv->yuv_info.osd_full_h = itv->is_out_50hz ? 576 : 480;
1157         itv->yuv_info.v4l2_src_w = itv->yuv_info.osd_full_w;
1158         itv->yuv_info.v4l2_src_h = itv->yuv_info.osd_full_h;
1159
1160         itv->params.video_gop_size = itv->is_60hz ? 15 : 12;
1161
1162         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_MPG] = 0x08000;
1163         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_PCM] = 0x01200;
1164         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_MPG] = 0x10000;
1165         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_YUV] = 0x10000;
1166         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_YUV] = 0x08000;
1167
1168         /* Setup VBI Raw Size. Should be big enough to hold PAL.
1169            It is possible to switch between PAL and NTSC, so we need to
1170            take the largest size here. */
1171         /* 1456 is multiple of 16, real size = 1444 */
1172         itv->vbi.raw_size = 1456;
1173         /* We use a buffer size of 1/2 of the total size needed for a
1174            frame. This is actually very useful, since we now receive
1175            a field at a time and that makes 'compressing' the raw data
1176            down to size by stripping off the SAV codes a lot easier.
1177            Note: having two different buffer sizes prevents standard
1178            switching on the fly. We need to find a better solution... */
1179         vbi_buf_size = itv->vbi.raw_size * (itv->is_60hz ? 24 : 36) / 2;
1180         itv->stream_buf_size[IVTV_ENC_STREAM_TYPE_VBI] = vbi_buf_size;
1181         itv->stream_buf_size[IVTV_DEC_STREAM_TYPE_VBI] = sizeof(struct v4l2_sliced_vbi_data) * 36;
1182
1183         if (itv->options.radio > 0)
1184                 itv->v4l2_cap |= V4L2_CAP_RADIO;
1185
1186         if (itv->options.tuner > -1) {
1187                 struct tuner_setup setup;
1188
1189                 setup.addr = ADDR_UNSET;
1190                 setup.type = itv->options.tuner;
1191                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
1192                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
1193                         ivtv_reset_tuner_gpio : NULL;
1194                 ivtv_call_i2c_clients(itv, TUNER_SET_TYPE_ADDR, &setup);
1195                 if (setup.type == TUNER_XC2028) {
1196                         static struct xc2028_ctrl ctrl = {
1197                                 .fname = XC2028_DEFAULT_FIRMWARE,
1198                                 .max_len = 64,
1199                         };
1200                         struct v4l2_priv_tun_config cfg = {
1201                                 .tuner = itv->options.tuner,
1202                                 .priv = &ctrl,
1203                         };
1204                         ivtv_call_i2c_clients(itv, TUNER_SET_CONFIG, &cfg);
1205                 }
1206         }
1207
1208         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
1209            are not. */
1210         itv->tuner_std = itv->std;
1211
1212         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1213                 ivtv_call_i2c_clients(itv, VIDIOC_INT_S_STD_OUTPUT, &itv->std);
1214         }
1215
1216         /* clear interrupt mask, effectively disabling interrupts */
1217         ivtv_set_irq_mask(itv, 0xffffffff);
1218
1219         /* Register IRQ */
1220         retval = request_irq(itv->dev->irq, ivtv_irq_handler,
1221                              IRQF_SHARED | IRQF_DISABLED, itv->name, (void *)itv);
1222         if (retval) {
1223                 IVTV_ERR("Failed to register irq %d\n", retval);
1224                 goto free_i2c;
1225         }
1226
1227         retval = ivtv_streams_setup(itv);
1228         if (retval) {
1229                 IVTV_ERR("Error %d setting up streams\n", retval);
1230                 goto free_irq;
1231         }
1232         retval = ivtv_streams_register(itv);
1233         if (retval) {
1234                 IVTV_ERR("Error %d registering devices\n", retval);
1235                 goto free_streams;
1236         }
1237         IVTV_INFO("Initialized card #%d: %s\n", itv->num, itv->card_name);
1238         return 0;
1239
1240 free_streams:
1241         ivtv_streams_cleanup(itv, 1);
1242 free_irq:
1243         free_irq(itv->dev->irq, (void *)itv);
1244 free_i2c:
1245         exit_ivtv_i2c(itv);
1246 free_io:
1247         ivtv_iounmap(itv);
1248 free_mem:
1249         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1250         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1251         if (itv->has_cx23415)
1252                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1253 free_workqueue:
1254         destroy_workqueue(itv->irq_work_queues);
1255 err:
1256         if (retval == 0)
1257                 retval = -ENODEV;
1258         IVTV_ERR("Error %d on initialization\n", retval);
1259
1260         spin_lock(&ivtv_cards_lock);
1261         kfree(ivtv_cards[ivtv_cards_active]);
1262         ivtv_cards[ivtv_cards_active] = NULL;
1263         spin_unlock(&ivtv_cards_lock);
1264         return retval;
1265 }
1266
1267 int ivtv_init_on_first_open(struct ivtv *itv)
1268 {
1269         struct v4l2_frequency vf;
1270         /* Needed to call ioctls later */
1271         struct ivtv_open_id fh;
1272         int fw_retry_count = 3;
1273         int video_input;
1274
1275         fh.itv = itv;
1276
1277         if (test_bit(IVTV_F_I_FAILED, &itv->i_flags))
1278                 return -ENXIO;
1279
1280         if (test_and_set_bit(IVTV_F_I_INITED, &itv->i_flags))
1281                 return 0;
1282
1283         while (--fw_retry_count > 0) {
1284                 /* load firmware */
1285                 if (ivtv_firmware_init(itv) == 0)
1286                         break;
1287                 if (fw_retry_count > 1)
1288                         IVTV_WARN("Retry loading firmware\n");
1289         }
1290
1291         if (fw_retry_count == 0) {
1292                 set_bit(IVTV_F_I_FAILED, &itv->i_flags);
1293                 return -ENXIO;
1294         }
1295
1296         /* Try and get firmware versions */
1297         IVTV_DEBUG_INFO("Getting firmware version..\n");
1298         ivtv_firmware_versions(itv);
1299
1300         if (itv->card->hw_all & IVTV_HW_CX25840) {
1301                 struct v4l2_control ctrl;
1302
1303                 /* CX25840_CID_ENABLE_PVR150_WORKAROUND */
1304                 ctrl.id = V4L2_CID_PRIVATE_BASE;
1305                 ctrl.value = itv->pvr150_workaround;
1306                 itv->video_dec_func(itv, VIDIOC_S_CTRL, &ctrl);
1307         }
1308
1309         vf.tuner = 0;
1310         vf.type = V4L2_TUNER_ANALOG_TV;
1311         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1312
1313         /* Set initial frequency. For PAL/SECAM broadcasts no
1314            'default' channel exists AFAIK. */
1315         if (itv->std == V4L2_STD_NTSC_M_JP) {
1316                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1317         }
1318         else if (itv->std & V4L2_STD_NTSC_M) {
1319                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1320         }
1321
1322         video_input = itv->active_input;
1323         itv->active_input++;    /* Force update of input */
1324         ivtv_s_input(NULL, &fh, video_input);
1325
1326         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1327            in one place. */
1328         itv->std++;             /* Force full standard initialization */
1329         itv->std_out = itv->std;
1330         ivtv_s_frequency(NULL, &fh, &vf);
1331
1332         if (itv->card->v4l2_capabilities & V4L2_CAP_VIDEO_OUTPUT) {
1333                 ivtv_init_mpeg_decoder(itv);
1334         }
1335         ivtv_s_std(NULL, &fh, &itv->tuner_std);
1336
1337         /* On a cx23416 this seems to be able to enable DMA to the chip? */
1338         if (!itv->has_cx23415)
1339                 write_reg_sync(0x03, IVTV_REG_DMACONTROL);
1340
1341         /* Default interrupts enabled. For the PVR350 this includes the
1342            decoder VSYNC interrupt, which is always on. It is not only used
1343            during decoding but also by the OSD.
1344            Some old PVR250 cards had a cx23415, so testing for that is too
1345            general. Instead test if the card has video output capability. */
1346         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
1347                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT | IVTV_IRQ_DEC_VSYNC);
1348                 ivtv_set_osd_alpha(itv);
1349         }
1350         else
1351                 ivtv_clear_irq_mask(itv, IVTV_IRQ_MASK_INIT);
1352         return 0;
1353 }
1354
1355 static void ivtv_remove(struct pci_dev *pci_dev)
1356 {
1357         struct ivtv *itv = pci_get_drvdata(pci_dev);
1358
1359         IVTV_DEBUG_INFO("Removing Card #%d\n", itv->num);
1360
1361         if (test_bit(IVTV_F_I_INITED, &itv->i_flags)) {
1362                 /* Stop all captures */
1363                 IVTV_DEBUG_INFO("Stopping all streams\n");
1364                 if (atomic_read(&itv->capturing) > 0)
1365                         ivtv_stop_all_captures(itv);
1366
1367                 /* Stop all decoding */
1368                 IVTV_DEBUG_INFO("Stopping decoding\n");
1369                 if (atomic_read(&itv->decoding) > 0) {
1370                         int type;
1371
1372                         if (test_bit(IVTV_F_I_DEC_YUV, &itv->i_flags))
1373                                 type = IVTV_DEC_STREAM_TYPE_YUV;
1374                         else
1375                                 type = IVTV_DEC_STREAM_TYPE_MPG;
1376                         ivtv_stop_v4l2_decode_stream(&itv->streams[type],
1377                                 VIDEO_CMD_STOP_TO_BLACK | VIDEO_CMD_STOP_IMMEDIATELY, 0);
1378                 }
1379                 ivtv_halt_firmware(itv);
1380         }
1381
1382         /* Interrupts */
1383         ivtv_set_irq_mask(itv, 0xffffffff);
1384         del_timer_sync(&itv->dma_timer);
1385
1386         /* Stop all Work Queues */
1387         flush_workqueue(itv->irq_work_queues);
1388         destroy_workqueue(itv->irq_work_queues);
1389
1390         ivtv_streams_cleanup(itv, 1);
1391         ivtv_udma_free(itv);
1392
1393         exit_ivtv_i2c(itv);
1394
1395         free_irq(itv->dev->irq, (void *)itv);
1396         ivtv_iounmap(itv);
1397
1398         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
1399         release_mem_region(itv->base_addr + IVTV_REG_OFFSET, IVTV_REG_SIZE);
1400         if (itv->has_cx23415)
1401                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
1402
1403         pci_disable_device(itv->dev);
1404
1405         IVTV_INFO("Removed %s, card #%d\n", itv->card_name, itv->num);
1406 }
1407
1408 /* define a pci_driver for card detection */
1409 static struct pci_driver ivtv_pci_driver = {
1410       .name =     "ivtv",
1411       .id_table = ivtv_pci_tbl,
1412       .probe =    ivtv_probe,
1413       .remove =   ivtv_remove,
1414 };
1415
1416 static int module_start(void)
1417 {
1418         printk(KERN_INFO "ivtv:  Start initialization, version %s\n", IVTV_VERSION);
1419
1420         memset(ivtv_cards, 0, sizeof(ivtv_cards));
1421
1422         /* Validate parameters */
1423         if (ivtv_first_minor < 0 || ivtv_first_minor >= IVTV_MAX_CARDS) {
1424                 printk(KERN_ERR "ivtv:  Exiting, ivtv_first_minor must be between 0 and %d\n",
1425                      IVTV_MAX_CARDS - 1);
1426                 return -1;
1427         }
1428
1429         if (ivtv_debug < 0 || ivtv_debug > 2047) {
1430                 ivtv_debug = 0;
1431                 printk(KERN_INFO "ivtv:  Debug value must be >= 0 and <= 2047\n");
1432         }
1433
1434         if (pci_register_driver(&ivtv_pci_driver)) {
1435                 printk(KERN_ERR "ivtv:  Error detecting PCI card\n");
1436                 return -ENODEV;
1437         }
1438         printk(KERN_INFO "ivtv:  End initialization\n");
1439         return 0;
1440 }
1441
1442 static void module_cleanup(void)
1443 {
1444         int i, j;
1445
1446         pci_unregister_driver(&ivtv_pci_driver);
1447
1448         spin_lock(&ivtv_cards_lock);
1449         for (i = 0; i < ivtv_cards_active; i++) {
1450                 if (ivtv_cards[i] == NULL)
1451                         continue;
1452                 for (j = 0; j < IVTV_VBI_FRAMES; j++) {
1453                         kfree(ivtv_cards[i]->vbi.sliced_mpeg_data[j]);
1454                 }
1455                 kfree(ivtv_cards[i]);
1456         }
1457         spin_unlock(&ivtv_cards_lock);
1458 }
1459
1460 /* Note: These symbols are exported because they are used by the ivtvfb
1461    framebuffer module and an infrared module for the IR-blaster. */
1462 EXPORT_SYMBOL(ivtv_set_irq_mask);
1463 EXPORT_SYMBOL(ivtv_cards_active);
1464 EXPORT_SYMBOL(ivtv_cards);
1465 EXPORT_SYMBOL(ivtv_cards_lock);
1466 EXPORT_SYMBOL(ivtv_api);
1467 EXPORT_SYMBOL(ivtv_vapi);
1468 EXPORT_SYMBOL(ivtv_vapi_result);
1469 EXPORT_SYMBOL(ivtv_clear_irq_mask);
1470 EXPORT_SYMBOL(ivtv_debug);
1471 EXPORT_SYMBOL(ivtv_reset_ir_gpio);
1472 EXPORT_SYMBOL(ivtv_udma_setup);
1473 EXPORT_SYMBOL(ivtv_udma_unmap);
1474 EXPORT_SYMBOL(ivtv_udma_alloc);
1475 EXPORT_SYMBOL(ivtv_udma_prepare);
1476 EXPORT_SYMBOL(ivtv_init_on_first_open);
1477
1478 module_init(module_start);
1479 module_exit(module_cleanup);