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