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