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