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