1 /* 2 * Copyright (C) 2010-2013 Bluecherry, LLC <http://www.bluecherrydvr.com> 3 * 4 * Original author: 5 * Ben Collins <bcollins@ubuntu.com> 6 * 7 * Additional work by: 8 * John Brooks <john.brooks@bluecherry.net> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/pci.h> 24 #include <linux/interrupt.h> 25 #include <linux/videodev2.h> 26 #include <linux/delay.h> 27 #include <linux/sysfs.h> 28 #include <linux/ktime.h> 29 #include <linux/slab.h> 30 31 #include "solo6x10.h" 32 #include "solo6x10-tw28.h" 33 34 MODULE_DESCRIPTION("Softlogic 6x10 MPEG4/H.264/G.723 CODEC V4L2/ALSA Driver"); 35 MODULE_AUTHOR("Bluecherry <maintainers@bluecherrydvr.com>"); 36 MODULE_VERSION(SOLO6X10_VERSION); 37 MODULE_LICENSE("GPL"); 38 39 static unsigned video_nr = -1; 40 module_param(video_nr, uint, 0644); 41 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect (default)"); 42 43 static int full_eeprom; /* default is only top 64B */ 44 module_param(full_eeprom, uint, 0644); 45 MODULE_PARM_DESC(full_eeprom, "Allow access to full 128B EEPROM (dangerous)"); 46 47 48 static void solo_set_time(struct solo_dev *solo_dev) 49 { 50 struct timespec ts; 51 52 ktime_get_ts(&ts); 53 54 solo_reg_write(solo_dev, SOLO_TIMER_SEC, ts.tv_sec); 55 solo_reg_write(solo_dev, SOLO_TIMER_USEC, ts.tv_nsec / NSEC_PER_USEC); 56 } 57 58 static void solo_timer_sync(struct solo_dev *solo_dev) 59 { 60 u32 sec, usec; 61 struct timespec ts; 62 long diff; 63 64 if (solo_dev->type != SOLO_DEV_6110) 65 return; 66 67 if (++solo_dev->time_sync < 60) 68 return; 69 70 solo_dev->time_sync = 0; 71 72 sec = solo_reg_read(solo_dev, SOLO_TIMER_SEC); 73 usec = solo_reg_read(solo_dev, SOLO_TIMER_USEC); 74 75 ktime_get_ts(&ts); 76 77 diff = (long)ts.tv_sec - (long)sec; 78 diff = (diff * 1000000) 79 + ((long)(ts.tv_nsec / NSEC_PER_USEC) - (long)usec); 80 81 if (diff > 1000 || diff < -1000) { 82 solo_set_time(solo_dev); 83 } else if (diff) { 84 long usec_lsb = solo_dev->usec_lsb; 85 86 usec_lsb -= diff / 4; 87 if (usec_lsb < 0) 88 usec_lsb = 0; 89 else if (usec_lsb > 255) 90 usec_lsb = 255; 91 92 solo_dev->usec_lsb = usec_lsb; 93 solo_reg_write(solo_dev, SOLO_TIMER_USEC_LSB, 94 solo_dev->usec_lsb); 95 } 96 } 97 98 static irqreturn_t solo_isr(int irq, void *data) 99 { 100 struct solo_dev *solo_dev = data; 101 u32 status; 102 int i; 103 104 status = solo_reg_read(solo_dev, SOLO_IRQ_STAT); 105 if (!status) 106 return IRQ_NONE; 107 108 if (status & ~solo_dev->irq_mask) { 109 solo_reg_write(solo_dev, SOLO_IRQ_STAT, 110 status & ~solo_dev->irq_mask); 111 status &= solo_dev->irq_mask; 112 } 113 114 if (status & SOLO_IRQ_PCI_ERR) 115 solo_p2m_error_isr(solo_dev); 116 117 for (i = 0; i < SOLO_NR_P2M; i++) 118 if (status & SOLO_IRQ_P2M(i)) 119 solo_p2m_isr(solo_dev, i); 120 121 if (status & SOLO_IRQ_IIC) 122 solo_i2c_isr(solo_dev); 123 124 if (status & SOLO_IRQ_VIDEO_IN) { 125 solo_video_in_isr(solo_dev); 126 solo_timer_sync(solo_dev); 127 } 128 129 if (status & SOLO_IRQ_ENCODER) 130 solo_enc_v4l2_isr(solo_dev); 131 132 if (status & SOLO_IRQ_G723) 133 solo_g723_isr(solo_dev); 134 135 /* Clear all interrupts handled */ 136 solo_reg_write(solo_dev, SOLO_IRQ_STAT, status); 137 138 return IRQ_HANDLED; 139 } 140 141 static void free_solo_dev(struct solo_dev *solo_dev) 142 { 143 struct pci_dev *pdev; 144 145 if (!solo_dev) 146 return; 147 148 if (solo_dev->dev.parent) 149 device_unregister(&solo_dev->dev); 150 151 pdev = solo_dev->pdev; 152 153 /* If we never initialized the PCI device, then nothing else 154 * below here needs cleanup */ 155 if (!pdev) { 156 kfree(solo_dev); 157 return; 158 } 159 160 if (solo_dev->reg_base) { 161 /* Bring down the sub-devices first */ 162 solo_g723_exit(solo_dev); 163 solo_enc_v4l2_exit(solo_dev); 164 solo_enc_exit(solo_dev); 165 solo_v4l2_exit(solo_dev); 166 solo_disp_exit(solo_dev); 167 solo_gpio_exit(solo_dev); 168 solo_p2m_exit(solo_dev); 169 solo_i2c_exit(solo_dev); 170 171 /* Now cleanup the PCI device */ 172 solo_irq_off(solo_dev, ~0); 173 pci_iounmap(pdev, solo_dev->reg_base); 174 if (pdev->irq) 175 free_irq(pdev->irq, solo_dev); 176 } 177 178 pci_release_regions(pdev); 179 pci_disable_device(pdev); 180 v4l2_device_unregister(&solo_dev->v4l2_dev); 181 pci_set_drvdata(pdev, NULL); 182 183 kfree(solo_dev); 184 } 185 186 static ssize_t eeprom_store(struct device *dev, struct device_attribute *attr, 187 const char *buf, size_t count) 188 { 189 struct solo_dev *solo_dev = 190 container_of(dev, struct solo_dev, dev); 191 unsigned short *p = (unsigned short *)buf; 192 int i; 193 194 if (count & 0x1) 195 dev_warn(dev, "EEPROM Write not aligned (truncating)\n"); 196 197 if (!full_eeprom && count > 64) { 198 dev_warn(dev, "EEPROM Write truncated to 64 bytes\n"); 199 count = 64; 200 } else if (full_eeprom && count > 128) { 201 dev_warn(dev, "EEPROM Write truncated to 128 bytes\n"); 202 count = 128; 203 } 204 205 solo_eeprom_ewen(solo_dev, 1); 206 207 for (i = full_eeprom ? 0 : 32; i < min((int)(full_eeprom ? 64 : 32), 208 (int)(count / 2)); i++) 209 solo_eeprom_write(solo_dev, i, cpu_to_be16(p[i])); 210 211 solo_eeprom_ewen(solo_dev, 0); 212 213 return count; 214 } 215 216 static ssize_t eeprom_show(struct device *dev, struct device_attribute *attr, 217 char *buf) 218 { 219 struct solo_dev *solo_dev = 220 container_of(dev, struct solo_dev, dev); 221 unsigned short *p = (unsigned short *)buf; 222 int count = (full_eeprom ? 128 : 64); 223 int i; 224 225 for (i = (full_eeprom ? 0 : 32); i < (count / 2); i++) 226 p[i] = be16_to_cpu(solo_eeprom_read(solo_dev, i)); 227 228 return count; 229 } 230 231 static ssize_t p2m_timeouts_show(struct device *dev, 232 struct device_attribute *attr, 233 char *buf) 234 { 235 struct solo_dev *solo_dev = 236 container_of(dev, struct solo_dev, dev); 237 238 return sprintf(buf, "%d\n", solo_dev->p2m_timeouts); 239 } 240 241 static ssize_t sdram_size_show(struct device *dev, 242 struct device_attribute *attr, 243 char *buf) 244 { 245 struct solo_dev *solo_dev = 246 container_of(dev, struct solo_dev, dev); 247 248 return sprintf(buf, "%dMegs\n", solo_dev->sdram_size >> 20); 249 } 250 251 static ssize_t tw28xx_show(struct device *dev, 252 struct device_attribute *attr, 253 char *buf) 254 { 255 struct solo_dev *solo_dev = 256 container_of(dev, struct solo_dev, dev); 257 258 return sprintf(buf, "tw2815[%d] tw2864[%d] tw2865[%d]\n", 259 hweight32(solo_dev->tw2815), 260 hweight32(solo_dev->tw2864), 261 hweight32(solo_dev->tw2865)); 262 } 263 264 static ssize_t input_map_show(struct device *dev, 265 struct device_attribute *attr, 266 char *buf) 267 { 268 struct solo_dev *solo_dev = 269 container_of(dev, struct solo_dev, dev); 270 unsigned int val; 271 char *out = buf; 272 273 val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_0); 274 out += sprintf(out, "Channel 0 => Input %d\n", val & 0x1f); 275 out += sprintf(out, "Channel 1 => Input %d\n", (val >> 5) & 0x1f); 276 out += sprintf(out, "Channel 2 => Input %d\n", (val >> 10) & 0x1f); 277 out += sprintf(out, "Channel 3 => Input %d\n", (val >> 15) & 0x1f); 278 out += sprintf(out, "Channel 4 => Input %d\n", (val >> 20) & 0x1f); 279 out += sprintf(out, "Channel 5 => Input %d\n", (val >> 25) & 0x1f); 280 281 val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_1); 282 out += sprintf(out, "Channel 6 => Input %d\n", val & 0x1f); 283 out += sprintf(out, "Channel 7 => Input %d\n", (val >> 5) & 0x1f); 284 out += sprintf(out, "Channel 8 => Input %d\n", (val >> 10) & 0x1f); 285 out += sprintf(out, "Channel 9 => Input %d\n", (val >> 15) & 0x1f); 286 out += sprintf(out, "Channel 10 => Input %d\n", (val >> 20) & 0x1f); 287 out += sprintf(out, "Channel 11 => Input %d\n", (val >> 25) & 0x1f); 288 289 val = solo_reg_read(solo_dev, SOLO_VI_CH_SWITCH_2); 290 out += sprintf(out, "Channel 12 => Input %d\n", val & 0x1f); 291 out += sprintf(out, "Channel 13 => Input %d\n", (val >> 5) & 0x1f); 292 out += sprintf(out, "Channel 14 => Input %d\n", (val >> 10) & 0x1f); 293 out += sprintf(out, "Channel 15 => Input %d\n", (val >> 15) & 0x1f); 294 out += sprintf(out, "Spot Output => Input %d\n", (val >> 20) & 0x1f); 295 296 return out - buf; 297 } 298 299 static ssize_t p2m_timeout_store(struct device *dev, 300 struct device_attribute *attr, 301 const char *buf, size_t count) 302 { 303 struct solo_dev *solo_dev = 304 container_of(dev, struct solo_dev, dev); 305 unsigned long ms; 306 int ret = kstrtoul(buf, 10, &ms); 307 308 if (ret < 0 || ms > 200) 309 return -EINVAL; 310 solo_dev->p2m_jiffies = msecs_to_jiffies(ms); 311 312 return count; 313 } 314 315 static ssize_t p2m_timeout_show(struct device *dev, 316 struct device_attribute *attr, 317 char *buf) 318 { 319 struct solo_dev *solo_dev = 320 container_of(dev, struct solo_dev, dev); 321 322 return sprintf(buf, "%ums\n", jiffies_to_msecs(solo_dev->p2m_jiffies)); 323 } 324 325 static ssize_t intervals_show(struct device *dev, 326 struct device_attribute *attr, 327 char *buf) 328 { 329 struct solo_dev *solo_dev = 330 container_of(dev, struct solo_dev, dev); 331 char *out = buf; 332 int fps = solo_dev->fps; 333 int i; 334 335 for (i = 0; i < solo_dev->nr_chans; i++) { 336 out += sprintf(out, "Channel %d: %d/%d (0x%08x)\n", 337 i, solo_dev->v4l2_enc[i]->interval, fps, 338 solo_reg_read(solo_dev, SOLO_CAP_CH_INTV(i))); 339 } 340 341 return out - buf; 342 } 343 344 static ssize_t sdram_offsets_show(struct device *dev, 345 struct device_attribute *attr, 346 char *buf) 347 { 348 struct solo_dev *solo_dev = 349 container_of(dev, struct solo_dev, dev); 350 char *out = buf; 351 352 out += sprintf(out, "DISP: 0x%08x @ 0x%08x\n", 353 SOLO_DISP_EXT_ADDR, 354 SOLO_DISP_EXT_SIZE); 355 356 out += sprintf(out, "EOSD: 0x%08x @ 0x%08x (0x%08x * %d)\n", 357 SOLO_EOSD_EXT_ADDR, 358 SOLO_EOSD_EXT_AREA(solo_dev), 359 SOLO_EOSD_EXT_SIZE(solo_dev), 360 SOLO_EOSD_EXT_AREA(solo_dev) / 361 SOLO_EOSD_EXT_SIZE(solo_dev)); 362 363 out += sprintf(out, "MOTI: 0x%08x @ 0x%08x\n", 364 SOLO_MOTION_EXT_ADDR(solo_dev), 365 SOLO_MOTION_EXT_SIZE); 366 367 out += sprintf(out, "G723: 0x%08x @ 0x%08x\n", 368 SOLO_G723_EXT_ADDR(solo_dev), 369 SOLO_G723_EXT_SIZE); 370 371 out += sprintf(out, "CAPT: 0x%08x @ 0x%08x (0x%08x * %d)\n", 372 SOLO_CAP_EXT_ADDR(solo_dev), 373 SOLO_CAP_EXT_SIZE(solo_dev), 374 SOLO_CAP_PAGE_SIZE, 375 SOLO_CAP_EXT_SIZE(solo_dev) / SOLO_CAP_PAGE_SIZE); 376 377 out += sprintf(out, "EREF: 0x%08x @ 0x%08x (0x%08x * %d)\n", 378 SOLO_EREF_EXT_ADDR(solo_dev), 379 SOLO_EREF_EXT_AREA(solo_dev), 380 SOLO_EREF_EXT_SIZE, 381 SOLO_EREF_EXT_AREA(solo_dev) / SOLO_EREF_EXT_SIZE); 382 383 out += sprintf(out, "MPEG: 0x%08x @ 0x%08x\n", 384 SOLO_MP4E_EXT_ADDR(solo_dev), 385 SOLO_MP4E_EXT_SIZE(solo_dev)); 386 387 out += sprintf(out, "JPEG: 0x%08x @ 0x%08x\n", 388 SOLO_JPEG_EXT_ADDR(solo_dev), 389 SOLO_JPEG_EXT_SIZE(solo_dev)); 390 391 return out - buf; 392 } 393 394 static ssize_t sdram_show(struct file *file, struct kobject *kobj, 395 struct bin_attribute *a, char *buf, 396 loff_t off, size_t count) 397 { 398 struct device *dev = container_of(kobj, struct device, kobj); 399 struct solo_dev *solo_dev = 400 container_of(dev, struct solo_dev, dev); 401 const int size = solo_dev->sdram_size; 402 403 if (off >= size) 404 return 0; 405 406 if (off + count > size) 407 count = size - off; 408 409 if (solo_p2m_dma(solo_dev, 0, buf, off, count, 0, 0)) 410 return -EIO; 411 412 return count; 413 } 414 415 static const struct device_attribute solo_dev_attrs[] = { 416 __ATTR(eeprom, 0640, eeprom_show, eeprom_store), 417 __ATTR(p2m_timeout, 0644, p2m_timeout_show, p2m_timeout_store), 418 __ATTR_RO(p2m_timeouts), 419 __ATTR_RO(sdram_size), 420 __ATTR_RO(tw28xx), 421 __ATTR_RO(input_map), 422 __ATTR_RO(intervals), 423 __ATTR_RO(sdram_offsets), 424 }; 425 426 static void solo_device_release(struct device *dev) 427 { 428 /* Do nothing */ 429 } 430 431 static int solo_sysfs_init(struct solo_dev *solo_dev) 432 { 433 struct bin_attribute *sdram_attr = &solo_dev->sdram_attr; 434 struct device *dev = &solo_dev->dev; 435 const char *driver; 436 int i; 437 438 if (solo_dev->type == SOLO_DEV_6110) 439 driver = "solo6110"; 440 else 441 driver = "solo6010"; 442 443 dev->release = solo_device_release; 444 dev->parent = &solo_dev->pdev->dev; 445 set_dev_node(dev, dev_to_node(&solo_dev->pdev->dev)); 446 dev_set_name(dev, "%s-%d-%d", driver, solo_dev->vfd->num, 447 solo_dev->nr_chans); 448 449 if (device_register(dev)) { 450 dev->parent = NULL; 451 return -ENOMEM; 452 } 453 454 for (i = 0; i < ARRAY_SIZE(solo_dev_attrs); i++) { 455 if (device_create_file(dev, &solo_dev_attrs[i])) { 456 device_unregister(dev); 457 return -ENOMEM; 458 } 459 } 460 461 sysfs_attr_init(&sdram_attr->attr); 462 sdram_attr->attr.name = "sdram"; 463 sdram_attr->attr.mode = 0440; 464 sdram_attr->read = sdram_show; 465 sdram_attr->size = solo_dev->sdram_size; 466 467 if (device_create_bin_file(dev, sdram_attr)) { 468 device_unregister(dev); 469 return -ENOMEM; 470 } 471 472 return 0; 473 } 474 475 static int solo_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 476 { 477 struct solo_dev *solo_dev; 478 int ret; 479 u8 chip_id; 480 481 solo_dev = kzalloc(sizeof(*solo_dev), GFP_KERNEL); 482 if (solo_dev == NULL) 483 return -ENOMEM; 484 485 if (id->driver_data == SOLO_DEV_6010) 486 dev_info(&pdev->dev, "Probing Softlogic 6010\n"); 487 else 488 dev_info(&pdev->dev, "Probing Softlogic 6110\n"); 489 490 solo_dev->type = id->driver_data; 491 solo_dev->pdev = pdev; 492 spin_lock_init(&solo_dev->reg_io_lock); 493 ret = v4l2_device_register(&pdev->dev, &solo_dev->v4l2_dev); 494 if (ret) 495 goto fail_probe; 496 497 /* Only for during init */ 498 solo_dev->p2m_jiffies = msecs_to_jiffies(100); 499 500 ret = pci_enable_device(pdev); 501 if (ret) 502 goto fail_probe; 503 504 pci_set_master(pdev); 505 506 /* RETRY/TRDY Timeout disabled */ 507 pci_write_config_byte(pdev, 0x40, 0x00); 508 pci_write_config_byte(pdev, 0x41, 0x00); 509 510 ret = pci_request_regions(pdev, SOLO6X10_NAME); 511 if (ret) 512 goto fail_probe; 513 514 solo_dev->reg_base = pci_ioremap_bar(pdev, 0); 515 if (solo_dev->reg_base == NULL) { 516 ret = -ENOMEM; 517 goto fail_probe; 518 } 519 520 chip_id = solo_reg_read(solo_dev, SOLO_CHIP_OPTION) & 521 SOLO_CHIP_ID_MASK; 522 switch (chip_id) { 523 case 7: 524 solo_dev->nr_chans = 16; 525 solo_dev->nr_ext = 5; 526 break; 527 case 6: 528 solo_dev->nr_chans = 8; 529 solo_dev->nr_ext = 2; 530 break; 531 default: 532 dev_warn(&pdev->dev, "Invalid chip_id 0x%02x, assuming 4 ch\n", 533 chip_id); 534 case 5: 535 solo_dev->nr_chans = 4; 536 solo_dev->nr_ext = 1; 537 } 538 539 /* Disable all interrupts to start */ 540 solo_irq_off(solo_dev, ~0); 541 542 /* Initial global settings */ 543 if (solo_dev->type == SOLO_DEV_6010) { 544 solo_dev->clock_mhz = 108; 545 solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT 546 | SOLO_SYS_CFG_INPUTDIV(25) 547 | SOLO_SYS_CFG_FEEDBACKDIV(solo_dev->clock_mhz * 2 - 2) 548 | SOLO_SYS_CFG_OUTDIV(3); 549 solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config); 550 } else { 551 u32 divq, divf; 552 553 solo_dev->clock_mhz = 135; 554 555 if (solo_dev->clock_mhz < 125) { 556 divq = 3; 557 divf = (solo_dev->clock_mhz * 4) / 3 - 1; 558 } else { 559 divq = 2; 560 divf = (solo_dev->clock_mhz * 2) / 3 - 1; 561 } 562 563 solo_reg_write(solo_dev, SOLO_PLL_CONFIG, 564 (1 << 20) | /* PLL_RANGE */ 565 (8 << 15) | /* PLL_DIVR */ 566 (divq << 12) | 567 (divf << 4) | 568 (1 << 1) /* PLL_FSEN */); 569 570 solo_dev->sys_config = SOLO_SYS_CFG_SDRAM64BIT; 571 } 572 573 solo_reg_write(solo_dev, SOLO_SYS_CFG, solo_dev->sys_config); 574 solo_reg_write(solo_dev, SOLO_TIMER_CLOCK_NUM, 575 solo_dev->clock_mhz - 1); 576 577 /* PLL locking time of 1ms */ 578 mdelay(1); 579 580 ret = request_irq(pdev->irq, solo_isr, IRQF_SHARED, SOLO6X10_NAME, 581 solo_dev); 582 if (ret) 583 goto fail_probe; 584 585 /* Handle this from the start */ 586 solo_irq_on(solo_dev, SOLO_IRQ_PCI_ERR); 587 588 ret = solo_i2c_init(solo_dev); 589 if (ret) 590 goto fail_probe; 591 592 /* Setup the DMA engine */ 593 solo_reg_write(solo_dev, SOLO_DMA_CTRL, 594 SOLO_DMA_CTRL_REFRESH_CYCLE(1) | 595 SOLO_DMA_CTRL_SDRAM_SIZE(2) | 596 SOLO_DMA_CTRL_SDRAM_CLK_INVERT | 597 SOLO_DMA_CTRL_READ_CLK_SELECT | 598 SOLO_DMA_CTRL_LATENCY(1)); 599 600 /* Undocumented crap */ 601 solo_reg_write(solo_dev, SOLO_DMA_CTRL1, 602 solo_dev->type == SOLO_DEV_6010 ? 0x100 : 0x300); 603 604 if (solo_dev->type != SOLO_DEV_6010) { 605 solo_dev->usec_lsb = 0x3f; 606 solo_set_time(solo_dev); 607 } 608 609 /* Disable watchdog */ 610 solo_reg_write(solo_dev, SOLO_WATCHDOG, 0); 611 612 /* Initialize sub components */ 613 614 ret = solo_p2m_init(solo_dev); 615 if (ret) 616 goto fail_probe; 617 618 ret = solo_disp_init(solo_dev); 619 if (ret) 620 goto fail_probe; 621 622 ret = solo_gpio_init(solo_dev); 623 if (ret) 624 goto fail_probe; 625 626 ret = solo_tw28_init(solo_dev); 627 if (ret) 628 goto fail_probe; 629 630 ret = solo_v4l2_init(solo_dev, video_nr); 631 if (ret) 632 goto fail_probe; 633 634 ret = solo_enc_init(solo_dev); 635 if (ret) 636 goto fail_probe; 637 638 ret = solo_enc_v4l2_init(solo_dev, video_nr); 639 if (ret) 640 goto fail_probe; 641 642 ret = solo_g723_init(solo_dev); 643 if (ret) 644 goto fail_probe; 645 646 ret = solo_sysfs_init(solo_dev); 647 if (ret) 648 goto fail_probe; 649 650 /* Now that init is over, set this lower */ 651 solo_dev->p2m_jiffies = msecs_to_jiffies(20); 652 653 return 0; 654 655 fail_probe: 656 free_solo_dev(solo_dev); 657 return ret; 658 } 659 660 static void solo_pci_remove(struct pci_dev *pdev) 661 { 662 struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev); 663 struct solo_dev *solo_dev = container_of(v4l2_dev, struct solo_dev, v4l2_dev); 664 665 free_solo_dev(solo_dev); 666 } 667 668 static const struct pci_device_id solo_id_table[] = { 669 /* 6010 based cards */ 670 { PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6010), 671 .driver_data = SOLO_DEV_6010 }, 672 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_4), 673 .driver_data = SOLO_DEV_6010 }, 674 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_9), 675 .driver_data = SOLO_DEV_6010 }, 676 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_NEUSOLO_16), 677 .driver_data = SOLO_DEV_6010 }, 678 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_4), 679 .driver_data = SOLO_DEV_6010 }, 680 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_9), 681 .driver_data = SOLO_DEV_6010 }, 682 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_SOLO_16), 683 .driver_data = SOLO_DEV_6010 }, 684 /* 6110 based cards */ 685 { PCI_DEVICE(PCI_VENDOR_ID_SOFTLOGIC, PCI_DEVICE_ID_SOLO6110), 686 .driver_data = SOLO_DEV_6110 }, 687 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_4), 688 .driver_data = SOLO_DEV_6110 }, 689 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_8), 690 .driver_data = SOLO_DEV_6110 }, 691 { PCI_DEVICE(PCI_VENDOR_ID_BLUECHERRY, PCI_DEVICE_ID_BC_6110_16), 692 .driver_data = SOLO_DEV_6110 }, 693 {0,} 694 }; 695 696 MODULE_DEVICE_TABLE(pci, solo_id_table); 697 698 static struct pci_driver solo_pci_driver = { 699 .name = SOLO6X10_NAME, 700 .id_table = solo_id_table, 701 .probe = solo_pci_probe, 702 .remove = solo_pci_remove, 703 }; 704 705 module_pci_driver(solo_pci_driver); 706