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