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