drivers/media/video/cx18/cx18-driver.c

   1 /*
   2  *  cx18 driver initialization and card probing
   3  *
   4  *  Derived from ivtv-driver.c
   5  *
   6  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
   7  *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  22  *  02111-1307  USA
  23  */
  24
  25 #include "cx18-driver.h"
  26 #include "cx18-io.h"
  27 #include "cx18-version.h"
  28 #include "cx18-cards.h"
  29 #include "cx18-i2c.h"
  30 #include "cx18-irq.h"
  31 #include "cx18-gpio.h"
  32 #include "cx18-firmware.h"
  33 #include "cx18-streams.h"
  34 #include "cx18-av-core.h"
  35 #include "cx18-scb.h"
  36 #include "cx18-mailbox.h"
  37 #include "cx18-ioctl.h"
  38 #include "tuner-xc2028.h"
  39
  40 #include <media/tveeprom.h>
  41
  42 /* If you have already X v4l cards, then set this to X. This way
  43    the device numbers stay matched. Example: you have a WinTV card
  44    without radio and a Compro H900 with. Normally this would give a
  45    video1 device together with a radio0 device for the Compro. By
  46    setting this to 1 you ensure that radio0 is now also radio1. */
  47 int cx18_first_minor;
  48
  49 /* add your revision and whatnot here */
  50 static struct pci_device_id cx18_pci_tbl[] __devinitdata = {
  51         {PCI_VENDOR_ID_CX, PCI_DEVICE_ID_CX23418,
  52          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  53         {0,}
  54 };
  55
  56 MODULE_DEVICE_TABLE(pci, cx18_pci_tbl);
  57
  58 static atomic_t cx18_instance = ATOMIC_INIT(0);
  59
  60 /* Parameter declarations */
  61 static int cardtype[CX18_MAX_CARDS];
  62 static int tuner[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  63                                      -1, -1, -1, -1, -1, -1, -1, -1,
  64                                      -1, -1, -1, -1, -1, -1, -1, -1,
  65                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  66 static int radio[CX18_MAX_CARDS] = { -1, -1, -1, -1, -1, -1, -1, -1,
  67                                      -1, -1, -1, -1, -1, -1, -1, -1,
  68                                      -1, -1, -1, -1, -1, -1, -1, -1,
  69                                      -1, -1, -1, -1, -1, -1, -1, -1 };
  70 static unsigned cardtype_c = 1;
  71 static unsigned tuner_c = 1;
  72 static unsigned radio_c = 1;
  73 static char pal[] = "--";
  74 static char secam[] = "--";
  75 static char ntsc[] = "-";
  76
  77 /* Buffers */
  78 static int enc_ts_buffers = CX18_DEFAULT_ENC_TS_BUFFERS;
  79 static int enc_mpg_buffers = CX18_DEFAULT_ENC_MPG_BUFFERS;
  80 static int enc_idx_buffers = CX18_DEFAULT_ENC_IDX_BUFFERS;
  81 static int enc_yuv_buffers = CX18_DEFAULT_ENC_YUV_BUFFERS;
  82 static int enc_vbi_buffers = CX18_DEFAULT_ENC_VBI_BUFFERS;
  83 static int enc_pcm_buffers = CX18_DEFAULT_ENC_PCM_BUFFERS;
  84
  85 static int enc_ts_bufsize = CX18_DEFAULT_ENC_TS_BUFSIZE;
  86 static int enc_mpg_bufsize = CX18_DEFAULT_ENC_MPG_BUFSIZE;
  87 static int enc_idx_bufsize = CX18_DEFAULT_ENC_IDX_BUFSIZE;
  88 static int enc_yuv_bufsize = CX18_DEFAULT_ENC_YUV_BUFSIZE;
  89 /* VBI bufsize based on standards supported by card tuner for now */
  90 static int enc_pcm_bufsize = CX18_DEFAULT_ENC_PCM_BUFSIZE;
  91
  92 static int enc_ts_bufs = -1;
  93 static int enc_mpg_bufs = -1;
  94 static int enc_idx_bufs = -1;
  95 static int enc_yuv_bufs = -1;
  96 static int enc_vbi_bufs = -1;
  97 static int enc_pcm_bufs = -1;
  98
  99
 100 static int cx18_pci_latency = 1;
 101
 102 static int mmio_ndelay;
 103 static int retry_mmio = 1;
 104
 105 int cx18_debug;
 106
 107 module_param_array(tuner, int, &tuner_c, 0644);
 108 module_param_array(radio, bool, &radio_c, 0644);
 109 module_param_array(cardtype, int, &cardtype_c, 0644);
 110 module_param_string(pal, pal, sizeof(pal), 0644);
 111 module_param_string(secam, secam, sizeof(secam), 0644);
 112 module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
 113 module_param_named(debug, cx18_debug, int, 0644);
 114 module_param(mmio_ndelay, int, 0644);
 115 module_param(retry_mmio, int, 0644);
 116 module_param(cx18_pci_latency, int, 0644);
 117 module_param(cx18_first_minor, int, 0644);
 118
 119 module_param(enc_ts_buffers, int, 0644);
 120 module_param(enc_mpg_buffers, int, 0644);
 121 module_param(enc_idx_buffers, int, 0644);
 122 module_param(enc_yuv_buffers, int, 0644);
 123 module_param(enc_vbi_buffers, int, 0644);
 124 module_param(enc_pcm_buffers, int, 0644);
 125
 126 module_param(enc_ts_bufsize, int, 0644);
 127 module_param(enc_mpg_bufsize, int, 0644);
 128 module_param(enc_idx_bufsize, int, 0644);
 129 module_param(enc_yuv_bufsize, int, 0644);
 130 /* VBI bufsize based on standards supported by card tuner for now */
 131 module_param(enc_pcm_bufsize, int, 0644);
 132
 133 module_param(enc_ts_bufs, int, 0644);
 134 module_param(enc_mpg_bufs, int, 0644);
 135 module_param(enc_idx_bufs, int, 0644);
 136 module_param(enc_yuv_bufs, int, 0644);
 137 module_param(enc_vbi_bufs, int, 0644);
 138 module_param(enc_pcm_bufs, int, 0644);
 139
 140 MODULE_PARM_DESC(tuner, "Tuner type selection,\n"
 141                         "\t\t\tsee tuner.h for values");
 142 MODULE_PARM_DESC(radio,
 143                  "Enable or disable the radio. Use only if autodetection\n"
 144                  "\t\t\tfails. 0 = disable, 1 = enable");
 145 MODULE_PARM_DESC(cardtype,
 146                  "Only use this option if your card is not detected properly.\n"
 147                  "\t\tSpecify card type:\n"
 148                  "\t\t\t 1 = Hauppauge HVR 1600 (ESMT memory)\n"
 149                  "\t\t\t 2 = Hauppauge HVR 1600 (Samsung memory)\n"
 150                  "\t\t\t 3 = Compro VideoMate H900\n"
 151                  "\t\t\t 4 = Yuan MPC718\n"
 152                  "\t\t\t 5 = Conexant Raptor PAL/SECAM\n"
 153                  "\t\t\t 6 = Toshiba Qosmio DVB-T/Analog\n"
 154                  "\t\t\t 7 = Leadtek WinFast PVR2100/DVR3100 H\n"
 155                  "\t\t\t 0 = Autodetect (default)\n"
 156                  "\t\t\t-1 = Ignore this card\n\t\t");
 157 MODULE_PARM_DESC(pal, "Set PAL standard: B, G, H, D, K, I, M, N, Nc, 60");
 158 MODULE_PARM_DESC(secam, "Set SECAM standard: B, G, H, D, K, L, LC");
 159 MODULE_PARM_DESC(ntsc, "Set NTSC standard: M, J, K");
 160 MODULE_PARM_DESC(debug,
 161                  "Debug level (bitmask). Default: 0\n"
 162                  "\t\t\t  1/0x0001: warning\n"
 163                  "\t\t\t  2/0x0002: info\n"
 164                  "\t\t\t  4/0x0004: mailbox\n"
 165                  "\t\t\t  8/0x0008: dma\n"
 166                  "\t\t\t 16/0x0010: ioctl\n"
 167                  "\t\t\t 32/0x0020: file\n"
 168                  "\t\t\t 64/0x0040: i2c\n"
 169                  "\t\t\t128/0x0080: irq\n"
 170                  "\t\t\t256/0x0100: high volume\n");
 171 MODULE_PARM_DESC(cx18_pci_latency,
 172                  "Change the PCI latency to 64 if lower: 0 = No, 1 = Yes,\n"
 173                  "\t\t\tDefault: Yes");
 174 MODULE_PARM_DESC(retry_mmio,
 175                  "(Deprecated) MMIO writes are now always checked and retried\n"
 176                  "\t\t\tEffectively: 1 [Yes]");
 177 MODULE_PARM_DESC(mmio_ndelay,
 178                  "(Deprecated) MMIO accesses are now never purposely delayed\n"
 179                  "\t\t\tEffectively: 0 ns");
 180 MODULE_PARM_DESC(enc_ts_buffers,
 181                  "Encoder TS buffer memory (MB). (enc_ts_bufs can override)\n"
 182                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFFERS));
 183 MODULE_PARM_DESC(enc_ts_bufsize,
 184                  "Size of an encoder TS buffer (kB)\n"
 185                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_TS_BUFSIZE));
 186 MODULE_PARM_DESC(enc_ts_bufs,
 187                  "Number of encoder TS buffers\n"
 188                  "\t\t\tDefault is computed from other enc_ts_* parameters");
 189 MODULE_PARM_DESC(enc_mpg_buffers,
 190                  "Encoder MPG buffer memory (MB). (enc_mpg_bufs can override)\n"
 191                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFFERS));
 192 MODULE_PARM_DESC(enc_mpg_bufsize,
 193                  "Size of an encoder MPG buffer (kB)\n"
 194                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_MPG_BUFSIZE));
 195 MODULE_PARM_DESC(enc_mpg_bufs,
 196                  "Number of encoder MPG buffers\n"
 197                  "\t\t\tDefault is computed from other enc_mpg_* parameters");
 198 MODULE_PARM_DESC(enc_idx_buffers,
 199                  "Encoder IDX buffer memory (MB). (enc_idx_bufs can override)\n"
 200                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFFERS));
 201 MODULE_PARM_DESC(enc_idx_bufsize,
 202                  "Size of an encoder IDX buffer (kB)\n"
 203                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_IDX_BUFSIZE));
 204 MODULE_PARM_DESC(enc_idx_bufs,
 205                  "Number of encoder IDX buffers\n"
 206                  "\t\t\tDefault is computed from other enc_idx_* parameters");
 207 MODULE_PARM_DESC(enc_yuv_buffers,
 208                  "Encoder YUV buffer memory (MB). (enc_yuv_bufs can override)\n"
 209                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFFERS));
 210 MODULE_PARM_DESC(enc_yuv_bufsize,
 211                  "Size of an encoder YUV buffer (kB)\n"
 212                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_YUV_BUFSIZE));
 213 MODULE_PARM_DESC(enc_yuv_bufs,
 214                  "Number of encoder YUV buffers\n"
 215                  "\t\t\tDefault is computed from other enc_yuv_* parameters");
 216 MODULE_PARM_DESC(enc_vbi_buffers,
 217                  "Encoder VBI buffer memory (MB). (enc_vbi_bufs can override)\n"
 218                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_VBI_BUFFERS));
 219 MODULE_PARM_DESC(enc_vbi_bufs,
 220                  "Number of encoder VBI buffers\n"
 221                  "\t\t\tDefault is computed from enc_vbi_buffers & tuner std");
 222 MODULE_PARM_DESC(enc_pcm_buffers,
 223                  "Encoder PCM buffer memory (MB). (enc_pcm_bufs can override)\n"
 224                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFFERS));
 225 MODULE_PARM_DESC(enc_pcm_bufsize,
 226                  "Size of an encoder PCM buffer (kB)\n"
 227                  "\t\t\tDefault: " __stringify(CX18_DEFAULT_ENC_PCM_BUFSIZE));
 228 MODULE_PARM_DESC(enc_pcm_bufs,
 229                  "Number of encoder PCM buffers\n"
 230                  "\t\t\tDefault is computed from other enc_pcm_* parameters");
 231
 232 MODULE_PARM_DESC(cx18_first_minor, "Set kernel number assigned to first card");
 233
 234 MODULE_AUTHOR("Hans Verkuil");
 235 MODULE_DESCRIPTION("CX23418 driver");
 236 MODULE_SUPPORTED_DEVICE("CX23418 MPEG2 encoder");
 237 MODULE_LICENSE("GPL");
 238
 239 MODULE_VERSION(CX18_VERSION);
 240
 241 /* Generic utility functions */
 242 int cx18_msleep_timeout(unsigned int msecs, int intr)
 243 {
 244         long int timeout = msecs_to_jiffies(msecs);
 245         int sig;
 246
 247         do {
 248                 set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
 249                 timeout = schedule_timeout(timeout);
 250                 sig = intr ? signal_pending(current) : 0;
 251         } while (!sig && timeout);
 252         return sig;
 253 }
 254
 255 /* Release ioremapped memory */
 256 static void cx18_iounmap(struct cx18 *cx)
 257 {
 258         if (cx == NULL)
 259                 return;
 260
 261         /* Release io memory */
 262         if (cx->enc_mem != NULL) {
 263                 CX18_DEBUG_INFO("releasing enc_mem\n");
 264                 iounmap(cx->enc_mem);
 265                 cx->enc_mem = NULL;
 266         }
 267 }
 268
 269 /* Hauppauge card? get values from tveeprom */
 270 void cx18_read_eeprom(struct cx18 *cx, struct tveeprom *tv)
 271 {
 272         struct i2c_client c;
 273         u8 eedata[256];
 274
 275         memset(&c, 0, sizeof(c));
 276         strlcpy(c.name, "cx18 tveeprom tmp", sizeof(c.name));
 277         c.adapter = &cx->i2c_adap[0];
 278         c.addr = 0xA0 >> 1;
 279
 280         tveeprom_read(&c, eedata, sizeof(eedata));
 281         tveeprom_hauppauge_analog(&c, tv, eedata);
 282 }
 283
 284 static void cx18_process_eeprom(struct cx18 *cx)
 285 {
 286         struct tveeprom tv;
 287
 288         cx18_read_eeprom(cx, &tv);
 289
 290         /* Many thanks to Steven Toth from Hauppauge for providing the
 291            model numbers */
 292         /* Note: the Samsung memory models cannot be reliably determined
 293            from the model number. Use the cardtype module option if you
 294            have one of these preproduction models. */
 295         switch (tv.model) {
 296         case 74000 ... 74999:
 297                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 298                 break;
 299         case 0:
 300                 CX18_ERR("Invalid EEPROM\n");
 301                 return;
 302         default:
 303                 CX18_ERR("Unknown model %d, defaulting to HVR-1600\n", tv.model);
 304                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 305                 break;
 306         }
 307
 308         cx->v4l2_cap = cx->card->v4l2_capabilities;
 309         cx->card_name = cx->card->name;
 310         cx->card_i2c = cx->card->i2c;
 311
 312         CX18_INFO("Autodetected %s\n", cx->card_name);
 313
 314         if (tv.tuner_type == TUNER_ABSENT)
 315                 CX18_ERR("tveeprom cannot autodetect tuner!");
 316
 317         if (cx->options.tuner == -1)
 318                 cx->options.tuner = tv.tuner_type;
 319         if (cx->options.radio == -1)
 320                 cx->options.radio = (tv.has_radio != 0);
 321
 322         if (cx->std != 0)
 323                 /* user specified tuner standard */
 324                 return;
 325
 326         /* autodetect tuner standard */
 327         if (tv.tuner_formats & V4L2_STD_PAL) {
 328                 CX18_DEBUG_INFO("PAL tuner detected\n");
 329                 cx->std |= V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 330         } else if (tv.tuner_formats & V4L2_STD_NTSC) {
 331                 CX18_DEBUG_INFO("NTSC tuner detected\n");
 332                 cx->std |= V4L2_STD_NTSC_M;
 333         } else if (tv.tuner_formats & V4L2_STD_SECAM) {
 334                 CX18_DEBUG_INFO("SECAM tuner detected\n");
 335                 cx->std |= V4L2_STD_SECAM_L;
 336         } else {
 337                 CX18_INFO("No tuner detected, default to NTSC-M\n");
 338                 cx->std |= V4L2_STD_NTSC_M;
 339         }
 340 }
 341
 342 static v4l2_std_id cx18_parse_std(struct cx18 *cx)
 343 {
 344         switch (pal[0]) {
 345         case '6':
 346                 return V4L2_STD_PAL_60;
 347         case 'b':
 348         case 'B':
 349         case 'g':
 350         case 'G':
 351                 return V4L2_STD_PAL_BG;
 352         case 'h':
 353         case 'H':
 354                 return V4L2_STD_PAL_H;
 355         case 'n':
 356         case 'N':
 357                 if (pal[1] == 'c' || pal[1] == 'C')
 358                         return V4L2_STD_PAL_Nc;
 359                 return V4L2_STD_PAL_N;
 360         case 'i':
 361         case 'I':
 362                 return V4L2_STD_PAL_I;
 363         case 'd':
 364         case 'D':
 365         case 'k':
 366         case 'K':
 367                 return V4L2_STD_PAL_DK;
 368         case 'M':
 369         case 'm':
 370                 return V4L2_STD_PAL_M;
 371         case '-':
 372                 break;
 373         default:
 374                 CX18_WARN("pal= argument not recognised\n");
 375                 return 0;
 376         }
 377
 378         switch (secam[0]) {
 379         case 'b':
 380         case 'B':
 381         case 'g':
 382         case 'G':
 383         case 'h':
 384         case 'H':
 385                 return V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
 386         case 'd':
 387         case 'D':
 388         case 'k':
 389         case 'K':
 390                 return V4L2_STD_SECAM_DK;
 391         case 'l':
 392         case 'L':
 393                 if (secam[1] == 'C' || secam[1] == 'c')
 394                         return V4L2_STD_SECAM_LC;
 395                 return V4L2_STD_SECAM_L;
 396         case '-':
 397                 break;
 398         default:
 399                 CX18_WARN("secam= argument not recognised\n");
 400                 return 0;
 401         }
 402
 403         switch (ntsc[0]) {
 404         case 'm':
 405         case 'M':
 406                 return V4L2_STD_NTSC_M;
 407         case 'j':
 408         case 'J':
 409                 return V4L2_STD_NTSC_M_JP;
 410         case 'k':
 411         case 'K':
 412                 return V4L2_STD_NTSC_M_KR;
 413         case '-':
 414                 break;
 415         default:
 416                 CX18_WARN("ntsc= argument not recognised\n");
 417                 return 0;
 418         }
 419
 420         /* no match found */
 421         return 0;
 422 }
 423
 424 static void cx18_process_options(struct cx18 *cx)
 425 {
 426         int i, j;
 427
 428         cx->options.megabytes[CX18_ENC_STREAM_TYPE_TS] = enc_ts_buffers;
 429         cx->options.megabytes[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_buffers;
 430         cx->options.megabytes[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_buffers;
 431         cx->options.megabytes[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_buffers;
 432         cx->options.megabytes[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_buffers;
 433         cx->options.megabytes[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_buffers;
 434         cx->options.megabytes[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control only */
 435
 436         cx->stream_buffers[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufs;
 437         cx->stream_buffers[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufs;
 438         cx->stream_buffers[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufs;
 439         cx->stream_buffers[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufs;
 440         cx->stream_buffers[CX18_ENC_STREAM_TYPE_VBI] = enc_vbi_bufs;
 441         cx->stream_buffers[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufs;
 442         cx->stream_buffers[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control, no data */
 443
 444         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_TS] = enc_ts_bufsize;
 445         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_MPG] = enc_mpg_bufsize;
 446         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_IDX] = enc_idx_bufsize;
 447         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_YUV] = enc_yuv_bufsize;
 448         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_VBI] = vbi_active_samples * 36;
 449         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_PCM] = enc_pcm_bufsize;
 450         cx->stream_buf_size[CX18_ENC_STREAM_TYPE_RAD] = 0; /* control no data */
 451
 452         /* Ensure stream_buffers & stream_buf_size are valid */
 453         for (i = 0; i < CX18_MAX_STREAMS; i++) {
 454                 if (cx->stream_buffers[i] == 0 ||     /* User said 0 buffers */
 455                     cx->options.megabytes[i] <= 0 ||  /* User said 0 MB total */
 456                     cx->stream_buf_size[i] <= 0) {    /* User said buf size 0 */
 457                         cx->options.megabytes[i] = 0;
 458                         cx->stream_buffers[i] = 0;
 459                         cx->stream_buf_size[i] = 0;
 460                         continue;
 461                 }
 462                 /*
 463                  * VBI is a special case where the stream_buf_size is fixed
 464                  * and already in bytes
 465                  */
 466                 if (i == CX18_ENC_STREAM_TYPE_VBI) {
 467                         if (cx->stream_buffers[i] < 0) {
 468                                 cx->stream_buffers[i] =
 469                                         cx->options.megabytes[i] * 1024 * 1024
 470                                         / cx->stream_buf_size[i];
 471                         } else {
 472                                 /* N.B. This might round down to 0 */
 473                                 cx->options.megabytes[i] =
 474                                         cx->stream_buffers[i]
 475                                         * cx->stream_buf_size[i]/(1024 * 1024);
 476                         }
 477                         continue;
 478                 }
 479                 /* All other streams have stream_buf_size in kB at this point */
 480                 if (cx->stream_buffers[i] < 0) {
 481                         cx->stream_buffers[i] = cx->options.megabytes[i] * 1024
 482                                                 / cx->stream_buf_size[i];
 483                 } else {
 484                         /* N.B. This might round down to 0 */
 485                         cx->options.megabytes[i] =
 486                           cx->stream_buffers[i] * cx->stream_buf_size[i] / 1024;
 487                 }
 488                 cx->stream_buf_size[i] *= 1024; /* convert from kB to bytes */
 489         }
 490
 491         cx->options.cardtype = cardtype[cx->instance];
 492         cx->options.tuner = tuner[cx->instance];
 493         cx->options.radio = radio[cx->instance];
 494
 495         cx->std = cx18_parse_std(cx);
 496         if (cx->options.cardtype == -1) {
 497                 CX18_INFO("Ignore card\n");
 498                 return;
 499         }
 500         cx->card = cx18_get_card(cx->options.cardtype - 1);
 501         if (cx->card)
 502                 CX18_INFO("User specified %s card\n", cx->card->name);
 503         else if (cx->options.cardtype != 0)
 504                 CX18_ERR("Unknown user specified type, trying to autodetect card\n");
 505         if (cx->card == NULL) {
 506                 if (cx->pci_dev->subsystem_vendor == CX18_PCI_ID_HAUPPAUGE) {
 507                         cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 508                         CX18_INFO("Autodetected Hauppauge card\n");
 509                 }
 510         }
 511         if (cx->card == NULL) {
 512                 for (i = 0; (cx->card = cx18_get_card(i)); i++) {
 513                         if (cx->card->pci_list == NULL)
 514                                 continue;
 515                         for (j = 0; cx->card->pci_list[j].device; j++) {
 516                                 if (cx->pci_dev->device !=
 517                                     cx->card->pci_list[j].device)
 518                                         continue;
 519                                 if (cx->pci_dev->subsystem_vendor !=
 520                                     cx->card->pci_list[j].subsystem_vendor)
 521                                         continue;
 522                                 if (cx->pci_dev->subsystem_device !=
 523                                     cx->card->pci_list[j].subsystem_device)
 524                                         continue;
 525                                 CX18_INFO("Autodetected %s card\n", cx->card->name);
 526                                 goto done;
 527                         }
 528                 }
 529         }
 530 done:
 531
 532         if (cx->card == NULL) {
 533                 cx->card = cx18_get_card(CX18_CARD_HVR_1600_ESMT);
 534                 CX18_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
 535                          cx->pci_dev->vendor, cx->pci_dev->device);
 536                 CX18_ERR("              subsystem vendor/device: [%04x:%04x]\n",
 537                          cx->pci_dev->subsystem_vendor,
 538                          cx->pci_dev->subsystem_device);
 539                 CX18_ERR("Defaulting to %s card\n", cx->card->name);
 540                 CX18_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
 541                 CX18_ERR("card you have to the ivtv-devel mailinglist (www.ivtvdriver.org)\n");
 542                 CX18_ERR("Prefix your subject line with [UNKNOWN CX18 CARD].\n");
 543         }
 544         cx->v4l2_cap = cx->card->v4l2_capabilities;
 545         cx->card_name = cx->card->name;
 546         cx->card_i2c = cx->card->i2c;
 547 }
 548
 549 /* Precondition: the cx18 structure has been memset to 0. Only
 550    the dev and instance fields have been filled in.
 551    No assumptions on the card type may be made here (see cx18_init_struct2
 552    for that).
 553  */
 554 static int __devinit cx18_init_struct1(struct cx18 *cx)
 555 {
 556         int i;
 557
 558         cx->base_addr = pci_resource_start(cx->pci_dev, 0);
 559
 560         mutex_init(&cx->serialize_lock);
 561         mutex_init(&cx->gpio_lock);
 562         mutex_init(&cx->epu2apu_mb_lock);
 563         mutex_init(&cx->epu2cpu_mb_lock);
 564
 565         snprintf(cx->in_workq_name, sizeof(cx->in_workq_name), "%s-in",
 566                  cx->v4l2_dev.name);
 567         cx->in_work_queue = create_singlethread_workqueue(cx->in_workq_name);
 568         if (cx->in_work_queue == NULL) {
 569                 CX18_ERR("Unable to create incoming mailbox handler thread\n");
 570                 return -ENOMEM;
 571         }
 572
 573         for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++) {
 574                 cx->in_work_order[i].cx = cx;
 575                 cx->in_work_order[i].str = cx->epu_debug_str;
 576                 INIT_WORK(&cx->in_work_order[i].work, cx18_in_work_handler);
 577         }
 578
 579         /* start counting open_id at 1 */
 580         cx->open_id = 1;
 581
 582         /* Initial settings */
 583         cx2341x_fill_defaults(&cx->params);
 584         cx->temporal_strength = cx->params.video_temporal_filter;
 585         cx->spatial_strength = cx->params.video_spatial_filter;
 586         cx->filter_mode = cx->params.video_spatial_filter_mode |
 587                 (cx->params.video_temporal_filter_mode << 1) |
 588                 (cx->params.video_median_filter_type << 2);
 589         cx->params.port = CX2341X_PORT_MEMORY;
 590         cx->params.capabilities =
 591                                 CX2341X_CAP_HAS_TS | CX2341X_CAP_HAS_SLICED_VBI;
 592         init_waitqueue_head(&cx->cap_w);
 593         init_waitqueue_head(&cx->mb_apu_waitq);
 594         init_waitqueue_head(&cx->mb_cpu_waitq);
 595         init_waitqueue_head(&cx->dma_waitq);
 596
 597         /* VBI */
 598         cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
 599         cx->vbi.sliced_in = &cx->vbi.in.fmt.sliced;
 600
 601         return 0;
 602 }
 603
 604 /* Second initialization part. Here the card type has been
 605    autodetected. */
 606 static void __devinit cx18_init_struct2(struct cx18 *cx)
 607 {
 608         int i;
 609
 610         for (i = 0; i < CX18_CARD_MAX_VIDEO_INPUTS; i++)
 611                 if (cx->card->video_inputs[i].video_type == 0)
 612                         break;
 613         cx->nof_inputs = i;
 614         for (i = 0; i < CX18_CARD_MAX_AUDIO_INPUTS; i++)
 615                 if (cx->card->audio_inputs[i].audio_type == 0)
 616                         break;
 617         cx->nof_audio_inputs = i;
 618
 619         /* Find tuner input */
 620         for (i = 0; i < cx->nof_inputs; i++) {
 621                 if (cx->card->video_inputs[i].video_type ==
 622                                 CX18_CARD_INPUT_VID_TUNER)
 623                         break;
 624         }
 625         if (i == cx->nof_inputs)
 626                 i = 0;
 627         cx->active_input = i;
 628         cx->audio_input = cx->card->video_inputs[i].audio_index;
 629 }
 630
 631 static int cx18_setup_pci(struct cx18 *cx, struct pci_dev *pci_dev,
 632                           const struct pci_device_id *pci_id)
 633 {
 634         u16 cmd;
 635         unsigned char pci_latency;
 636
 637         CX18_DEBUG_INFO("Enabling pci device\n");
 638
 639         if (pci_enable_device(pci_dev)) {
 640                 CX18_ERR("Can't enable device %d!\n", cx->instance);
 641                 return -EIO;
 642         }
 643         if (pci_set_dma_mask(pci_dev, 0xffffffff)) {
 644                 CX18_ERR("No suitable DMA available, card %d\n", cx->instance);
 645                 return -EIO;
 646         }
 647         if (!request_mem_region(cx->base_addr, CX18_MEM_SIZE, "cx18 encoder")) {
 648                 CX18_ERR("Cannot request encoder memory region, card %d\n",
 649                          cx->instance);
 650                 return -EIO;
 651         }
 652
 653         /* Enable bus mastering and memory mapped IO for the CX23418 */
 654         pci_read_config_word(pci_dev, PCI_COMMAND, &cmd);
 655         cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
 656         pci_write_config_word(pci_dev, PCI_COMMAND, cmd);
 657
 658         pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &cx->card_rev);
 659         pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 660
 661         if (pci_latency < 64 && cx18_pci_latency) {
 662                 CX18_INFO("Unreasonably low latency timer, "
 663                                "setting to 64 (was %d)\n", pci_latency);
 664                 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, 64);
 665                 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &pci_latency);
 666         }
 667
 668         CX18_DEBUG_INFO("cx%d (rev %d) at %02x:%02x.%x, "
 669                    "irq: %d, latency: %d, memory: 0x%lx\n",
 670                    cx->pci_dev->device, cx->card_rev, pci_dev->bus->number,
 671                    PCI_SLOT(pci_dev->devfn), PCI_FUNC(pci_dev->devfn),
 672                    cx->pci_dev->irq, pci_latency, (unsigned long)cx->base_addr);
 673
 674         return 0;
 675 }
 676
 677 static void cx18_init_subdevs(struct cx18 *cx)
 678 {
 679         u32 hw = cx->card->hw_all;
 680         u32 device;
 681         int i;
 682
 683         for (i = 0, device = 1; i < 32; i++, device <<= 1) {
 684
 685                 if (!(device & hw))
 686                         continue;
 687
 688                 switch (device) {
 689                 case CX18_HW_DVB:
 690                 case CX18_HW_TVEEPROM:
 691                         /* These subordinate devices do not use probing */
 692                         cx->hw_flags |= device;
 693                         break;
 694                 case CX18_HW_418_AV:
 695                         /* The A/V decoder gets probed earlier to set PLLs */
 696                         /* Just note that the card uses it (i.e. has analog) */
 697                         cx->hw_flags |= device;
 698                         break;
 699                 case CX18_HW_GPIO_RESET_CTRL:
 700                         /*
 701                          * The Reset Controller gets probed and added to
 702                          * hw_flags earlier for i2c adapter/bus initialization
 703                          */
 704                         break;
 705                 case CX18_HW_GPIO_MUX:
 706                         if (cx18_gpio_register(cx, device) == 0)
 707                                 cx->hw_flags |= device;
 708                         break;
 709                 default:
 710                         if (cx18_i2c_register(cx, i) == 0)
 711                                 cx->hw_flags |= device;
 712                         break;
 713                 }
 714         }
 715
 716         if (cx->hw_flags & CX18_HW_418_AV)
 717                 cx->sd_av = cx18_find_hw(cx, CX18_HW_418_AV);
 718
 719         if (cx->card->hw_muxer != 0)
 720                 cx->sd_extmux = cx18_find_hw(cx, cx->card->hw_muxer);
 721 }
 722
 723 static int __devinit cx18_probe(struct pci_dev *pci_dev,
 724                                 const struct pci_device_id *pci_id)
 725 {
 726         int retval = 0;
 727         int i;
 728         u32 devtype;
 729         struct cx18 *cx;
 730
 731         /* FIXME - module parameter arrays constrain max instances */
 732         i = atomic_inc_return(&cx18_instance) - 1;
 733         if (i >= CX18_MAX_CARDS) {
 734                 printk(KERN_ERR "cx18: cannot manage card %d, driver has a "
 735                        "limit of 0 - %d\n", i, CX18_MAX_CARDS - 1);
 736                 return -ENOMEM;
 737         }
 738
 739         cx = kzalloc(sizeof(struct cx18), GFP_ATOMIC);
 740         if (cx == NULL) {
 741                 printk(KERN_ERR "cx18: cannot manage card %d, out of memory\n",
 742                        i);
 743                 return -ENOMEM;
 744         }
 745         cx->pci_dev = pci_dev;
 746         cx->instance = i;
 747
 748         retval = v4l2_device_register(&pci_dev->dev, &cx->v4l2_dev);
 749         if (retval) {
 750                 printk(KERN_ERR "cx18: v4l2_device_register of card %d failed"
 751                        "\n", cx->instance);
 752                 kfree(cx);
 753                 return retval;
 754         }
 755         snprintf(cx->v4l2_dev.name, sizeof(cx->v4l2_dev.name), "cx18-%d",
 756                  cx->instance);
 757         CX18_INFO("Initializing card %d\n", cx->instance);
 758
 759         cx18_process_options(cx);
 760         if (cx->options.cardtype == -1) {
 761                 retval = -ENODEV;
 762                 goto err;
 763         }
 764         if (cx18_init_struct1(cx)) {
 765                 retval = -ENOMEM;
 766                 goto err;
 767         }
 768
 769         CX18_DEBUG_INFO("base addr: 0x%08x\n", cx->base_addr);
 770
 771         /* PCI Device Setup */
 772         retval = cx18_setup_pci(cx, pci_dev, pci_id);
 773         if (retval != 0)
 774                 goto free_workqueue;
 775
 776         /* map io memory */
 777         CX18_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
 778                    cx->base_addr + CX18_MEM_OFFSET, CX18_MEM_SIZE);
 779         cx->enc_mem = ioremap_nocache(cx->base_addr + CX18_MEM_OFFSET,
 780                                        CX18_MEM_SIZE);
 781         if (!cx->enc_mem) {
 782                 CX18_ERR("ioremap failed, perhaps increasing __VMALLOC_RESERVE in page.h\n");
 783                 CX18_ERR("or disabling CONFIG_HIGHMEM4G into the kernel would help\n");
 784                 retval = -ENOMEM;
 785                 goto free_mem;
 786         }
 787         cx->reg_mem = cx->enc_mem + CX18_REG_OFFSET;
 788         devtype = cx18_read_reg(cx, 0xC72028);
 789         switch (devtype & 0xff000000) {
 790         case 0xff000000:
 791                 CX18_INFO("cx23418 revision %08x (A)\n", devtype);
 792                 break;
 793         case 0x01000000:
 794                 CX18_INFO("cx23418 revision %08x (B)\n", devtype);
 795                 break;
 796         default:
 797                 CX18_INFO("cx23418 revision %08x (Unknown)\n", devtype);
 798                 break;
 799         }
 800
 801         cx18_init_power(cx, 1);
 802         cx18_init_memory(cx);
 803
 804         cx->scb = (struct cx18_scb __iomem *)(cx->enc_mem + SCB_OFFSET);
 805         cx18_init_scb(cx);
 806
 807         cx18_gpio_init(cx);
 808
 809         /* Initialize integrated A/V decoder early to set PLLs, just in case */
 810         retval = cx18_av_probe(cx);
 811         if (retval) {
 812                 CX18_ERR("Could not register A/V decoder subdevice\n");
 813                 goto free_map;
 814         }
 815         cx18_call_hw(cx, CX18_HW_418_AV, core, init, 0);
 816
 817         /* Initialize GPIO Reset Controller to do chip resets during i2c init */
 818         if (cx->card->hw_all & CX18_HW_GPIO_RESET_CTRL) {
 819                 if (cx18_gpio_register(cx, CX18_HW_GPIO_RESET_CTRL) != 0)
 820                         CX18_WARN("Could not register GPIO reset controller"
 821                                   "subdevice; proceeding anyway.\n");
 822                 else
 823                         cx->hw_flags |= CX18_HW_GPIO_RESET_CTRL;
 824         }
 825
 826         /* active i2c  */
 827         CX18_DEBUG_INFO("activating i2c...\n");
 828         retval = init_cx18_i2c(cx);
 829         if (retval) {
 830                 CX18_ERR("Could not initialize i2c\n");
 831                 goto free_map;
 832         }
 833
 834         if (cx->card->hw_all & CX18_HW_TVEEPROM) {
 835                 /* Based on the model number the cardtype may be changed.
 836                    The PCI IDs are not always reliable. */
 837                 cx18_process_eeprom(cx);
 838         }
 839         if (cx->card->comment)
 840                 CX18_INFO("%s", cx->card->comment);
 841         if (cx->card->v4l2_capabilities == 0) {
 842                 retval = -ENODEV;
 843                 goto free_i2c;
 844         }
 845         cx18_init_memory(cx);
 846         cx18_init_scb(cx);
 847
 848         /* Register IRQ */
 849         retval = request_irq(cx->pci_dev->irq, cx18_irq_handler,
 850                              IRQF_SHARED | IRQF_DISABLED,
 851                              cx->v4l2_dev.name, (void *)cx);
 852         if (retval) {
 853                 CX18_ERR("Failed to register irq %d\n", retval);
 854                 goto free_i2c;
 855         }
 856
 857         if (cx->std == 0)
 858                 cx->std = V4L2_STD_NTSC_M;
 859
 860         if (cx->options.tuner == -1) {
 861                 for (i = 0; i < CX18_CARD_MAX_TUNERS; i++) {
 862                         if ((cx->std & cx->card->tuners[i].std) == 0)
 863                                 continue;
 864                         cx->options.tuner = cx->card->tuners[i].tuner;
 865                         break;
 866                 }
 867         }
 868         /* if no tuner was found, then pick the first tuner in the card list */
 869         if (cx->options.tuner == -1 && cx->card->tuners[0].std) {
 870                 cx->std = cx->card->tuners[0].std;
 871                 if (cx->std & V4L2_STD_PAL)
 872                         cx->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H;
 873                 else if (cx->std & V4L2_STD_NTSC)
 874                         cx->std = V4L2_STD_NTSC_M;
 875                 else if (cx->std & V4L2_STD_SECAM)
 876                         cx->std = V4L2_STD_SECAM_L;
 877                 cx->options.tuner = cx->card->tuners[0].tuner;
 878         }
 879         if (cx->options.radio == -1)
 880                 cx->options.radio = (cx->card->radio_input.audio_type != 0);
 881
 882         /* The card is now fully identified, continue with card-specific
 883            initialization. */
 884         cx18_init_struct2(cx);
 885
 886         cx18_init_subdevs(cx);
 887
 888         if (cx->std & V4L2_STD_525_60)
 889                 cx->is_60hz = 1;
 890         else
 891                 cx->is_50hz = 1;
 892
 893         cx->params.video_gop_size = cx->is_60hz ? 15 : 12;
 894
 895         if (cx->options.radio > 0)
 896                 cx->v4l2_cap |= V4L2_CAP_RADIO;
 897
 898         if (cx->options.tuner > -1) {
 899                 struct tuner_setup setup;
 900
 901                 setup.addr = ADDR_UNSET;
 902                 setup.type = cx->options.tuner;
 903                 setup.mode_mask = T_ANALOG_TV;  /* matches TV tuners */
 904                 setup.tuner_callback = (setup.type == TUNER_XC2028) ?
 905                         cx18_reset_tuner_gpio : NULL;
 906                 cx18_call_all(cx, tuner, s_type_addr, &setup);
 907                 if (setup.type == TUNER_XC2028) {
 908                         static struct xc2028_ctrl ctrl = {
 909                                 .fname = XC2028_DEFAULT_FIRMWARE,
 910                                 .max_len = 64,
 911                         };
 912                         struct v4l2_priv_tun_config cfg = {
 913                                 .tuner = cx->options.tuner,
 914                                 .priv = &ctrl,
 915                         };
 916                         cx18_call_all(cx, tuner, s_config, &cfg);
 917                 }
 918         }
 919
 920         /* The tuner is fixed to the standard. The other inputs (e.g. S-Video)
 921            are not. */
 922         cx->tuner_std = cx->std;
 923
 924         retval = cx18_streams_setup(cx);
 925         if (retval) {
 926                 CX18_ERR("Error %d setting up streams\n", retval);
 927                 goto free_irq;
 928         }
 929         retval = cx18_streams_register(cx);
 930         if (retval) {
 931                 CX18_ERR("Error %d registering devices\n", retval);
 932                 goto free_streams;
 933         }
 934
 935         CX18_INFO("Initialized card: %s\n", cx->card_name);
 936         return 0;
 937
 938 free_streams:
 939         cx18_streams_cleanup(cx, 1);
 940 free_irq:
 941         free_irq(cx->pci_dev->irq, (void *)cx);
 942 free_i2c:
 943         exit_cx18_i2c(cx);
 944 free_map:
 945         cx18_iounmap(cx);
 946 free_mem:
 947         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
 948 free_workqueue:
 949         destroy_workqueue(cx->in_work_queue);
 950 err:
 951         if (retval == 0)
 952                 retval = -ENODEV;
 953         CX18_ERR("Error %d on initialization\n", retval);
 954
 955         v4l2_device_unregister(&cx->v4l2_dev);
 956         kfree(cx);
 957         return retval;
 958 }
 959
 960 int cx18_init_on_first_open(struct cx18 *cx)
 961 {
 962         int video_input;
 963         int fw_retry_count = 3;
 964         struct v4l2_frequency vf;
 965         struct cx18_open_id fh;
 966
 967         fh.cx = cx;
 968
 969         if (test_bit(CX18_F_I_FAILED, &cx->i_flags))
 970                 return -ENXIO;
 971
 972         if (test_and_set_bit(CX18_F_I_INITED, &cx->i_flags))
 973                 return 0;
 974
 975         while (--fw_retry_count > 0) {
 976                 /* load firmware */
 977                 if (cx18_firmware_init(cx) == 0)
 978                         break;
 979                 if (fw_retry_count > 1)
 980                         CX18_WARN("Retry loading firmware\n");
 981         }
 982
 983         if (fw_retry_count == 0) {
 984                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
 985                 return -ENXIO;
 986         }
 987         set_bit(CX18_F_I_LOADED_FW, &cx->i_flags);
 988
 989         /*
 990          * Init the firmware twice to work around a silicon bug
 991          * with the digital TS.
 992          *
 993          * The second firmware load requires us to normalize the APU state,
 994          * or the audio for the first analog capture will be badly incorrect.
 995          *
 996          * I can't seem to call APU_RESETAI and have it succeed without the
 997          * APU capturing audio, so we start and stop it here to do the reset
 998          */
 999
1000         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1001         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1002         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1003         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1004
1005         fw_retry_count = 3;
1006         while (--fw_retry_count > 0) {
1007                 /* load firmware */
1008                 if (cx18_firmware_init(cx) == 0)
1009                         break;
1010                 if (fw_retry_count > 1)
1011                         CX18_WARN("Retry loading firmware\n");
1012         }
1013
1014         if (fw_retry_count == 0) {
1015                 set_bit(CX18_F_I_FAILED, &cx->i_flags);
1016                 return -ENXIO;
1017         }
1018
1019         /*
1020          * The second firmware load requires us to normalize the APU state,
1021          * or the audio for the first analog capture will be badly incorrect.
1022          *
1023          * I can't seem to call APU_RESETAI and have it succeed without the
1024          * APU capturing audio, so we start and stop it here to do the reset
1025          */
1026
1027         /* MPEG Encoding, 224 kbps, MPEG Layer II, 48 ksps */
1028         cx18_vapi(cx, CX18_APU_START, 2, CX18_APU_ENCODING_METHOD_MPEG|0xb9, 0);
1029         cx18_vapi(cx, CX18_APU_RESETAI, 0);
1030         cx18_vapi(cx, CX18_APU_STOP, 1, CX18_APU_ENCODING_METHOD_MPEG);
1031
1032         /* Init the A/V decoder, if it hasn't been already */
1033         v4l2_subdev_call(cx->sd_av, core, load_fw);
1034
1035         vf.tuner = 0;
1036         vf.type = V4L2_TUNER_ANALOG_TV;
1037         vf.frequency = 6400; /* the tuner 'baseline' frequency */
1038
1039         /* Set initial frequency. For PAL/SECAM broadcasts no
1040            'default' channel exists AFAIK. */
1041         if (cx->std == V4L2_STD_NTSC_M_JP)
1042                 vf.frequency = 1460;    /* ch. 1 91250*16/1000 */
1043         else if (cx->std & V4L2_STD_NTSC_M)
1044                 vf.frequency = 1076;    /* ch. 4 67250*16/1000 */
1045
1046         video_input = cx->active_input;
1047         cx->active_input++;     /* Force update of input */
1048         cx18_s_input(NULL, &fh, video_input);
1049
1050         /* Let the VIDIOC_S_STD ioctl do all the work, keeps the code
1051            in one place. */
1052         cx->std++;              /* Force full standard initialization */
1053         cx18_s_std(NULL, &fh, &cx->tuner_std);
1054         cx18_s_frequency(NULL, &fh, &vf);
1055         return 0;
1056 }
1057
1058 static void cx18_cancel_in_work_orders(struct cx18 *cx)
1059 {
1060         int i;
1061         for (i = 0; i < CX18_MAX_IN_WORK_ORDERS; i++)
1062                 cancel_work_sync(&cx->in_work_order[i].work);
1063 }
1064
1065 static void cx18_remove(struct pci_dev *pci_dev)
1066 {
1067         struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
1068         struct cx18 *cx = to_cx18(v4l2_dev);
1069         int i;
1070
1071         CX18_DEBUG_INFO("Removing Card\n");
1072
1073         /* Stop all captures */
1074         CX18_DEBUG_INFO("Stopping all streams\n");
1075         if (atomic_read(&cx->tot_capturing) > 0)
1076                 cx18_stop_all_captures(cx);
1077
1078         /* Interrupts */
1079         cx18_sw1_irq_disable(cx, IRQ_CPU_TO_EPU | IRQ_APU_TO_EPU);
1080         cx18_sw2_irq_disable(cx, IRQ_CPU_TO_EPU_ACK | IRQ_APU_TO_EPU_ACK);
1081
1082         cx18_halt_firmware(cx);
1083
1084         cx18_cancel_in_work_orders(cx);
1085
1086         destroy_workqueue(cx->in_work_queue);
1087
1088         cx18_streams_cleanup(cx, 1);
1089
1090         exit_cx18_i2c(cx);
1091
1092         free_irq(cx->pci_dev->irq, (void *)cx);
1093
1094         cx18_iounmap(cx);
1095
1096         release_mem_region(cx->base_addr, CX18_MEM_SIZE);
1097
1098         pci_disable_device(cx->pci_dev);
1099
1100         if (cx->vbi.sliced_mpeg_data[0] != NULL)
1101                 for (i = 0; i < CX18_VBI_FRAMES; i++)
1102                         kfree(cx->vbi.sliced_mpeg_data[i]);
1103
1104         CX18_INFO("Removed %s\n", cx->card_name);
1105
1106         v4l2_device_unregister(v4l2_dev);
1107         kfree(cx);
1108 }
1109
1110 /* define a pci_driver for card detection */
1111 static struct pci_driver cx18_pci_driver = {
1112       .name =     "cx18",
1113       .id_table = cx18_pci_tbl,
1114       .probe =    cx18_probe,
1115       .remove =   cx18_remove,
1116 };
1117
1118 static int module_start(void)
1119 {
1120         printk(KERN_INFO "cx18:  Start initialization, version %s\n", CX18_VERSION);
1121
1122         /* Validate parameters */
1123         if (cx18_first_minor < 0 || cx18_first_minor >= CX18_MAX_CARDS) {
1124                 printk(KERN_ERR "cx18:  Exiting, cx18_first_minor must be between 0 and %d\n",
1125                      CX18_MAX_CARDS - 1);
1126                 return -1;
1127         }
1128
1129         if (cx18_debug < 0 || cx18_debug > 511) {
1130                 cx18_debug = 0;
1131                 printk(KERN_INFO "cx18:   Debug value must be >= 0 and <= 511!\n");
1132         }
1133
1134         if (pci_register_driver(&cx18_pci_driver)) {
1135                 printk(KERN_ERR "cx18:   Error detecting PCI card\n");
1136                 return -ENODEV;
1137         }
1138         printk(KERN_INFO "cx18:  End initialization\n");
1139         return 0;
1140 }
1141
1142 static void module_cleanup(void)
1143 {
1144         pci_unregister_driver(&cx18_pci_driver);
1145 }
1146
1147 module_init(module_start);
1148 module_exit(module_cleanup);