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