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