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