1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * 4 * Support for the mpeg transport stream transfers 5 * PCI function #2 of the cx2388x. 6 * 7 * (c) 2004 Jelle Foks <jelle@foks.us> 8 * (c) 2004 Chris Pascoe <c.pascoe@itee.uq.edu.au> 9 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> 10 */ 11 12 #include "cx88.h" 13 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <linux/init.h> 17 #include <linux/device.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/interrupt.h> 20 #include <linux/delay.h> 21 22 /* ------------------------------------------------------------------ */ 23 24 MODULE_DESCRIPTION("mpeg driver for cx2388x based TV cards"); 25 MODULE_AUTHOR("Jelle Foks <jelle@foks.us>"); 26 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>"); 27 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]"); 28 MODULE_LICENSE("GPL"); 29 MODULE_VERSION(CX88_VERSION); 30 31 static unsigned int debug; 32 module_param(debug, int, 0644); 33 MODULE_PARM_DESC(debug, "enable debug messages [mpeg]"); 34 35 #define dprintk(level, fmt, arg...) do { \ 36 if (debug + 1 > level) \ 37 printk(KERN_DEBUG pr_fmt("%s: mpeg:" fmt), \ 38 __func__, ##arg); \ 39 } while (0) 40 41 #if defined(CONFIG_MODULES) && defined(MODULE) 42 static void request_module_async(struct work_struct *work) 43 { 44 struct cx8802_dev *dev = container_of(work, struct cx8802_dev, 45 request_module_wk); 46 47 if (dev->core->board.mpeg & CX88_MPEG_DVB) 48 request_module("cx88-dvb"); 49 if (dev->core->board.mpeg & CX88_MPEG_BLACKBIRD) 50 request_module("cx88-blackbird"); 51 } 52 53 static void request_modules(struct cx8802_dev *dev) 54 { 55 INIT_WORK(&dev->request_module_wk, request_module_async); 56 schedule_work(&dev->request_module_wk); 57 } 58 59 static void flush_request_modules(struct cx8802_dev *dev) 60 { 61 flush_work(&dev->request_module_wk); 62 } 63 #else 64 #define request_modules(dev) 65 #define flush_request_modules(dev) 66 #endif /* CONFIG_MODULES */ 67 68 static LIST_HEAD(cx8802_devlist); 69 static DEFINE_MUTEX(cx8802_mutex); 70 /* ------------------------------------------------------------------ */ 71 72 int cx8802_start_dma(struct cx8802_dev *dev, 73 struct cx88_dmaqueue *q, 74 struct cx88_buffer *buf) 75 { 76 struct cx88_core *core = dev->core; 77 78 dprintk(1, "w: %d, h: %d, f: %d\n", 79 core->width, core->height, core->field); 80 81 /* setup fifo + format */ 82 cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28], 83 dev->ts_packet_size, buf->risc.dma); 84 85 /* write TS length to chip */ 86 cx_write(MO_TS_LNGTH, dev->ts_packet_size); 87 88 /* 89 * FIXME: this needs a review. 90 * also: move to cx88-blackbird + cx88-dvb source files? 91 */ 92 93 dprintk(1, "core->active_type_id = 0x%08x\n", core->active_type_id); 94 95 if ((core->active_type_id == CX88_MPEG_DVB) && 96 (core->board.mpeg & CX88_MPEG_DVB)) { 97 dprintk(1, "cx8802_start_dma doing .dvb\n"); 98 /* negedge driven & software reset */ 99 cx_write(TS_GEN_CNTRL, 0x0040 | dev->ts_gen_cntrl); 100 udelay(100); 101 cx_write(MO_PINMUX_IO, 0x00); 102 cx_write(TS_HW_SOP_CNTRL, 0x47 << 16 | 188 << 4 | 0x01); 103 switch (core->boardnr) { 104 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q: 105 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T: 106 case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD: 107 case CX88_BOARD_PCHDTV_HD5500: 108 cx_write(TS_SOP_STAT, 1 << 13); 109 break; 110 case CX88_BOARD_SAMSUNG_SMT_7020: 111 cx_write(TS_SOP_STAT, 0x00); 112 break; 113 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1: 114 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1: 115 /* Enable MPEG parallel IO and video signal pins */ 116 cx_write(MO_PINMUX_IO, 0x88); 117 udelay(100); 118 break; 119 case CX88_BOARD_HAUPPAUGE_HVR1300: 120 /* Enable MPEG parallel IO and video signal pins */ 121 cx_write(MO_PINMUX_IO, 0x88); 122 cx_write(TS_SOP_STAT, 0); 123 cx_write(TS_VALERR_CNTRL, 0); 124 break; 125 case CX88_BOARD_PINNACLE_PCTV_HD_800i: 126 /* Enable MPEG parallel IO and video signal pins */ 127 cx_write(MO_PINMUX_IO, 0x88); 128 cx_write(TS_HW_SOP_CNTRL, (0x47 << 16) | (188 << 4)); 129 dev->ts_gen_cntrl = 5; 130 cx_write(TS_SOP_STAT, 0); 131 cx_write(TS_VALERR_CNTRL, 0); 132 udelay(100); 133 break; 134 default: 135 cx_write(TS_SOP_STAT, 0x00); 136 break; 137 } 138 cx_write(TS_GEN_CNTRL, dev->ts_gen_cntrl); 139 udelay(100); 140 } else if ((core->active_type_id == CX88_MPEG_BLACKBIRD) && 141 (core->board.mpeg & CX88_MPEG_BLACKBIRD)) { 142 dprintk(1, "cx8802_start_dma doing .blackbird\n"); 143 cx_write(MO_PINMUX_IO, 0x88); /* enable MPEG parallel IO */ 144 145 /* punctured clock TS & posedge driven & software reset */ 146 cx_write(TS_GEN_CNTRL, 0x46); 147 udelay(100); 148 149 cx_write(TS_HW_SOP_CNTRL, 0x408); /* mpeg start byte */ 150 cx_write(TS_VALERR_CNTRL, 0x2000); 151 152 /* punctured clock TS & posedge driven */ 153 cx_write(TS_GEN_CNTRL, 0x06); 154 udelay(100); 155 } else { 156 pr_err("%s() Failed. Unsupported value in .mpeg (0x%08x)\n", 157 __func__, core->board.mpeg); 158 return -EINVAL; 159 } 160 161 /* reset counter */ 162 cx_write(MO_TS_GPCNTRL, GP_COUNT_CONTROL_RESET); 163 q->count = 0; 164 165 /* clear interrupt status register */ 166 cx_write(MO_TS_INTSTAT, 0x1f1111); 167 168 /* enable irqs */ 169 dprintk(1, "setting the interrupt mask\n"); 170 cx_set(MO_PCI_INTMSK, core->pci_irqmask | PCI_INT_TSINT); 171 cx_set(MO_TS_INTMSK, 0x1f0011); 172 173 /* start dma */ 174 cx_set(MO_DEV_CNTRL2, (1 << 5)); 175 cx_set(MO_TS_DMACNTRL, 0x11); 176 return 0; 177 } 178 EXPORT_SYMBOL(cx8802_start_dma); 179 180 static int cx8802_stop_dma(struct cx8802_dev *dev) 181 { 182 struct cx88_core *core = dev->core; 183 184 dprintk(1, "\n"); 185 186 /* stop dma */ 187 cx_clear(MO_TS_DMACNTRL, 0x11); 188 189 /* disable irqs */ 190 cx_clear(MO_PCI_INTMSK, PCI_INT_TSINT); 191 cx_clear(MO_TS_INTMSK, 0x1f0011); 192 193 /* Reset the controller */ 194 cx_write(TS_GEN_CNTRL, 0xcd); 195 return 0; 196 } 197 198 static int cx8802_restart_queue(struct cx8802_dev *dev, 199 struct cx88_dmaqueue *q) 200 { 201 struct cx88_buffer *buf; 202 203 dprintk(1, "\n"); 204 if (list_empty(&q->active)) 205 return 0; 206 207 buf = list_entry(q->active.next, struct cx88_buffer, list); 208 dprintk(2, "restart_queue [%p/%d]: restart dma\n", 209 buf, buf->vb.vb2_buf.index); 210 cx8802_start_dma(dev, q, buf); 211 return 0; 212 } 213 214 /* ------------------------------------------------------------------ */ 215 216 int cx8802_buf_prepare(struct vb2_queue *q, struct cx8802_dev *dev, 217 struct cx88_buffer *buf) 218 { 219 int size = dev->ts_packet_size * dev->ts_packet_count; 220 struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0); 221 struct cx88_riscmem *risc = &buf->risc; 222 int rc; 223 224 if (vb2_plane_size(&buf->vb.vb2_buf, 0) < size) 225 return -EINVAL; 226 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size); 227 228 rc = cx88_risc_databuffer(dev->pci, risc, sgt->sgl, 229 dev->ts_packet_size, dev->ts_packet_count, 0); 230 if (rc) { 231 if (risc->cpu) 232 dma_free_coherent(&dev->pci->dev, risc->size, 233 risc->cpu, risc->dma); 234 memset(risc, 0, sizeof(*risc)); 235 return rc; 236 } 237 return 0; 238 } 239 EXPORT_SYMBOL(cx8802_buf_prepare); 240 241 void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf) 242 { 243 struct cx88_buffer *prev; 244 struct cx88_dmaqueue *cx88q = &dev->mpegq; 245 246 dprintk(1, "\n"); 247 /* add jump to start */ 248 buf->risc.cpu[1] = cpu_to_le32(buf->risc.dma + 8); 249 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_CNT_INC); 250 buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma + 8); 251 252 if (list_empty(&cx88q->active)) { 253 dprintk(1, "queue is empty - first active\n"); 254 list_add_tail(&buf->list, &cx88q->active); 255 dprintk(1, "[%p/%d] %s - first active\n", 256 buf, buf->vb.vb2_buf.index, __func__); 257 258 } else { 259 buf->risc.cpu[0] |= cpu_to_le32(RISC_IRQ1); 260 dprintk(1, "queue is not empty - append to active\n"); 261 prev = list_entry(cx88q->active.prev, struct cx88_buffer, list); 262 list_add_tail(&buf->list, &cx88q->active); 263 prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 264 dprintk(1, "[%p/%d] %s - append to active\n", 265 buf, buf->vb.vb2_buf.index, __func__); 266 } 267 } 268 EXPORT_SYMBOL(cx8802_buf_queue); 269 270 /* ----------------------------------------------------------- */ 271 272 static void do_cancel_buffers(struct cx8802_dev *dev) 273 { 274 struct cx88_dmaqueue *q = &dev->mpegq; 275 struct cx88_buffer *buf; 276 unsigned long flags; 277 278 spin_lock_irqsave(&dev->slock, flags); 279 while (!list_empty(&q->active)) { 280 buf = list_entry(q->active.next, struct cx88_buffer, list); 281 list_del(&buf->list); 282 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 283 } 284 spin_unlock_irqrestore(&dev->slock, flags); 285 } 286 287 void cx8802_cancel_buffers(struct cx8802_dev *dev) 288 { 289 dprintk(1, "\n"); 290 cx8802_stop_dma(dev); 291 do_cancel_buffers(dev); 292 } 293 EXPORT_SYMBOL(cx8802_cancel_buffers); 294 295 static const char *cx88_mpeg_irqs[32] = { 296 "ts_risci1", NULL, NULL, NULL, 297 "ts_risci2", NULL, NULL, NULL, 298 "ts_oflow", NULL, NULL, NULL, 299 "ts_sync", NULL, NULL, NULL, 300 "opc_err", "par_err", "rip_err", "pci_abort", 301 "ts_err?", 302 }; 303 304 static void cx8802_mpeg_irq(struct cx8802_dev *dev) 305 { 306 struct cx88_core *core = dev->core; 307 u32 status, mask, count; 308 309 dprintk(1, "\n"); 310 status = cx_read(MO_TS_INTSTAT); 311 mask = cx_read(MO_TS_INTMSK); 312 if (0 == (status & mask)) 313 return; 314 315 cx_write(MO_TS_INTSTAT, status); 316 317 if (debug || (status & mask & ~0xff)) 318 cx88_print_irqbits("irq mpeg ", 319 cx88_mpeg_irqs, ARRAY_SIZE(cx88_mpeg_irqs), 320 status, mask); 321 322 /* risc op code error */ 323 if (status & (1 << 16)) { 324 pr_warn("mpeg risc op code error\n"); 325 cx_clear(MO_TS_DMACNTRL, 0x11); 326 cx88_sram_channel_dump(dev->core, 327 &cx88_sram_channels[SRAM_CH28]); 328 } 329 330 /* risc1 y */ 331 if (status & 0x01) { 332 dprintk(1, "wake up\n"); 333 spin_lock(&dev->slock); 334 count = cx_read(MO_TS_GPCNT); 335 cx88_wakeup(dev->core, &dev->mpegq, count); 336 spin_unlock(&dev->slock); 337 } 338 339 /* other general errors */ 340 if (status & 0x1f0100) { 341 dprintk(0, "general errors: 0x%08x\n", status & 0x1f0100); 342 spin_lock(&dev->slock); 343 cx8802_stop_dma(dev); 344 spin_unlock(&dev->slock); 345 } 346 } 347 348 #define MAX_IRQ_LOOP 10 349 350 static irqreturn_t cx8802_irq(int irq, void *dev_id) 351 { 352 struct cx8802_dev *dev = dev_id; 353 struct cx88_core *core = dev->core; 354 u32 status; 355 int loop, handled = 0; 356 357 for (loop = 0; loop < MAX_IRQ_LOOP; loop++) { 358 status = cx_read(MO_PCI_INTSTAT) & 359 (core->pci_irqmask | PCI_INT_TSINT); 360 if (status == 0) 361 goto out; 362 dprintk(1, "cx8802_irq\n"); 363 dprintk(1, " loop: %d/%d\n", loop, MAX_IRQ_LOOP); 364 dprintk(1, " status: %d\n", status); 365 handled = 1; 366 cx_write(MO_PCI_INTSTAT, status); 367 368 if (status & core->pci_irqmask) 369 cx88_core_irq(core, status); 370 if (status & PCI_INT_TSINT) 371 cx8802_mpeg_irq(dev); 372 } 373 if (loop == MAX_IRQ_LOOP) { 374 dprintk(0, "clearing mask\n"); 375 pr_warn("irq loop -- clearing mask\n"); 376 cx_write(MO_PCI_INTMSK, 0); 377 } 378 379 out: 380 return IRQ_RETVAL(handled); 381 } 382 383 static int cx8802_init_common(struct cx8802_dev *dev) 384 { 385 struct cx88_core *core = dev->core; 386 int err; 387 388 /* pci init */ 389 if (pci_enable_device(dev->pci)) 390 return -EIO; 391 pci_set_master(dev->pci); 392 err = dma_set_mask(&dev->pci->dev, DMA_BIT_MASK(32)); 393 if (err) { 394 pr_err("Oops: no 32bit PCI DMA ???\n"); 395 return -EIO; 396 } 397 398 dev->pci_rev = dev->pci->revision; 399 pci_read_config_byte(dev->pci, PCI_LATENCY_TIMER, &dev->pci_lat); 400 pr_info("found at %s, rev: %d, irq: %d, latency: %d, mmio: 0x%llx\n", 401 pci_name(dev->pci), dev->pci_rev, dev->pci->irq, 402 dev->pci_lat, 403 (unsigned long long)pci_resource_start(dev->pci, 0)); 404 405 /* initialize driver struct */ 406 spin_lock_init(&dev->slock); 407 408 /* init dma queue */ 409 INIT_LIST_HEAD(&dev->mpegq.active); 410 411 /* get irq */ 412 err = request_irq(dev->pci->irq, cx8802_irq, 413 IRQF_SHARED, dev->core->name, dev); 414 if (err < 0) { 415 pr_err("can't get IRQ %d\n", dev->pci->irq); 416 return err; 417 } 418 cx_set(MO_PCI_INTMSK, core->pci_irqmask); 419 420 /* everything worked */ 421 pci_set_drvdata(dev->pci, dev); 422 return 0; 423 } 424 425 static void cx8802_fini_common(struct cx8802_dev *dev) 426 { 427 dprintk(2, "\n"); 428 cx8802_stop_dma(dev); 429 pci_disable_device(dev->pci); 430 431 /* unregister stuff */ 432 free_irq(dev->pci->irq, dev); 433 } 434 435 /* ----------------------------------------------------------- */ 436 437 static int cx8802_suspend_common(struct pci_dev *pci_dev, pm_message_t state) 438 { 439 struct cx8802_dev *dev = pci_get_drvdata(pci_dev); 440 unsigned long flags; 441 442 /* stop mpeg dma */ 443 spin_lock_irqsave(&dev->slock, flags); 444 if (!list_empty(&dev->mpegq.active)) { 445 dprintk(2, "suspend\n"); 446 pr_info("suspend mpeg\n"); 447 cx8802_stop_dma(dev); 448 } 449 spin_unlock_irqrestore(&dev->slock, flags); 450 451 /* FIXME -- shutdown device */ 452 cx88_shutdown(dev->core); 453 454 pci_save_state(pci_dev); 455 if (pci_set_power_state(pci_dev, 456 pci_choose_state(pci_dev, state)) != 0) { 457 pci_disable_device(pci_dev); 458 dev->state.disabled = 1; 459 } 460 return 0; 461 } 462 463 static int cx8802_resume_common(struct pci_dev *pci_dev) 464 { 465 struct cx8802_dev *dev = pci_get_drvdata(pci_dev); 466 unsigned long flags; 467 int err; 468 469 if (dev->state.disabled) { 470 err = pci_enable_device(pci_dev); 471 if (err) { 472 pr_err("can't enable device\n"); 473 return err; 474 } 475 dev->state.disabled = 0; 476 } 477 err = pci_set_power_state(pci_dev, PCI_D0); 478 if (err) { 479 pr_err("can't enable device\n"); 480 pci_disable_device(pci_dev); 481 dev->state.disabled = 1; 482 483 return err; 484 } 485 pci_restore_state(pci_dev); 486 487 /* FIXME: re-initialize hardware */ 488 cx88_reset(dev->core); 489 490 /* restart video+vbi capture */ 491 spin_lock_irqsave(&dev->slock, flags); 492 if (!list_empty(&dev->mpegq.active)) { 493 pr_info("resume mpeg\n"); 494 cx8802_restart_queue(dev, &dev->mpegq); 495 } 496 spin_unlock_irqrestore(&dev->slock, flags); 497 498 return 0; 499 } 500 501 struct cx8802_driver *cx8802_get_driver(struct cx8802_dev *dev, 502 enum cx88_board_type btype) 503 { 504 struct cx8802_driver *d; 505 506 list_for_each_entry(d, &dev->drvlist, drvlist) 507 if (d->type_id == btype) 508 return d; 509 510 return NULL; 511 } 512 EXPORT_SYMBOL(cx8802_get_driver); 513 514 /* Driver asked for hardware access. */ 515 static int cx8802_request_acquire(struct cx8802_driver *drv) 516 { 517 struct cx88_core *core = drv->core; 518 unsigned int i; 519 520 /* Fail a request for hardware if the device is busy. */ 521 if (core->active_type_id != CX88_BOARD_NONE && 522 core->active_type_id != drv->type_id) 523 return -EBUSY; 524 525 if (drv->type_id == CX88_MPEG_DVB) { 526 /* When switching to DVB, always set the input to the tuner */ 527 core->last_analog_input = core->input; 528 core->input = 0; 529 for (i = 0; 530 i < ARRAY_SIZE(core->board.input); 531 i++) { 532 if (core->board.input[i].type == CX88_VMUX_DVB) { 533 core->input = i; 534 break; 535 } 536 } 537 } 538 539 if (drv->advise_acquire) { 540 core->active_ref++; 541 if (core->active_type_id == CX88_BOARD_NONE) { 542 core->active_type_id = drv->type_id; 543 drv->advise_acquire(drv); 544 } 545 546 dprintk(1, "Post acquire GPIO=%x\n", cx_read(MO_GP0_IO)); 547 } 548 549 return 0; 550 } 551 552 /* Driver asked to release hardware. */ 553 static int cx8802_request_release(struct cx8802_driver *drv) 554 { 555 struct cx88_core *core = drv->core; 556 557 if (drv->advise_release && --core->active_ref == 0) { 558 if (drv->type_id == CX88_MPEG_DVB) { 559 /* 560 * If the DVB driver is releasing, reset the input 561 * state to the last configured analog input 562 */ 563 core->input = core->last_analog_input; 564 } 565 566 drv->advise_release(drv); 567 core->active_type_id = CX88_BOARD_NONE; 568 dprintk(1, "Post release GPIO=%x\n", cx_read(MO_GP0_IO)); 569 } 570 571 return 0; 572 } 573 574 static int cx8802_check_driver(struct cx8802_driver *drv) 575 { 576 if (!drv) 577 return -ENODEV; 578 579 if ((drv->type_id != CX88_MPEG_DVB) && 580 (drv->type_id != CX88_MPEG_BLACKBIRD)) 581 return -EINVAL; 582 583 if ((drv->hw_access != CX8802_DRVCTL_SHARED) && 584 (drv->hw_access != CX8802_DRVCTL_EXCLUSIVE)) 585 return -EINVAL; 586 587 if ((!drv->probe) || 588 (!drv->remove) || 589 (!drv->advise_acquire) || 590 (!drv->advise_release)) 591 return -EINVAL; 592 593 return 0; 594 } 595 596 int cx8802_register_driver(struct cx8802_driver *drv) 597 { 598 struct cx8802_dev *dev; 599 struct cx8802_driver *driver; 600 int err, i = 0; 601 602 pr_info("registering cx8802 driver, type: %s access: %s\n", 603 drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird", 604 drv->hw_access == CX8802_DRVCTL_SHARED ? 605 "shared" : "exclusive"); 606 607 err = cx8802_check_driver(drv); 608 if (err) { 609 pr_err("cx8802_driver is invalid\n"); 610 return err; 611 } 612 613 mutex_lock(&cx8802_mutex); 614 615 list_for_each_entry(dev, &cx8802_devlist, devlist) { 616 pr_info("subsystem: %04x:%04x, board: %s [card=%d]\n", 617 dev->pci->subsystem_vendor, 618 dev->pci->subsystem_device, dev->core->board.name, 619 dev->core->boardnr); 620 621 /* Bring up a new struct for each driver instance */ 622 driver = kzalloc(sizeof(*drv), GFP_KERNEL); 623 if (!driver) { 624 err = -ENOMEM; 625 goto out; 626 } 627 628 /* Snapshot of the driver registration data */ 629 drv->core = dev->core; 630 drv->suspend = cx8802_suspend_common; 631 drv->resume = cx8802_resume_common; 632 drv->request_acquire = cx8802_request_acquire; 633 drv->request_release = cx8802_request_release; 634 memcpy(driver, drv, sizeof(*driver)); 635 636 mutex_lock(&drv->core->lock); 637 err = drv->probe(driver); 638 if (err == 0) { 639 i++; 640 list_add_tail(&driver->drvlist, &dev->drvlist); 641 } else { 642 pr_err("cx8802 probe failed, err = %d\n", err); 643 } 644 mutex_unlock(&drv->core->lock); 645 } 646 647 err = i ? 0 : -ENODEV; 648 out: 649 mutex_unlock(&cx8802_mutex); 650 return err; 651 } 652 EXPORT_SYMBOL(cx8802_register_driver); 653 654 int cx8802_unregister_driver(struct cx8802_driver *drv) 655 { 656 struct cx8802_dev *dev; 657 struct cx8802_driver *d, *dtmp; 658 int err = 0; 659 660 pr_info("unregistering cx8802 driver, type: %s access: %s\n", 661 drv->type_id == CX88_MPEG_DVB ? "dvb" : "blackbird", 662 drv->hw_access == CX8802_DRVCTL_SHARED ? 663 "shared" : "exclusive"); 664 665 mutex_lock(&cx8802_mutex); 666 667 list_for_each_entry(dev, &cx8802_devlist, devlist) { 668 pr_info("subsystem: %04x:%04x, board: %s [card=%d]\n", 669 dev->pci->subsystem_vendor, 670 dev->pci->subsystem_device, dev->core->board.name, 671 dev->core->boardnr); 672 673 mutex_lock(&dev->core->lock); 674 675 list_for_each_entry_safe(d, dtmp, &dev->drvlist, drvlist) { 676 /* only unregister the correct driver type */ 677 if (d->type_id != drv->type_id) 678 continue; 679 680 err = d->remove(d); 681 if (err == 0) { 682 list_del(&d->drvlist); 683 kfree(d); 684 } else 685 pr_err("cx8802 driver remove failed (%d)\n", 686 err); 687 } 688 689 mutex_unlock(&dev->core->lock); 690 } 691 692 mutex_unlock(&cx8802_mutex); 693 694 return err; 695 } 696 EXPORT_SYMBOL(cx8802_unregister_driver); 697 698 /* ----------------------------------------------------------- */ 699 static int cx8802_probe(struct pci_dev *pci_dev, 700 const struct pci_device_id *pci_id) 701 { 702 struct cx8802_dev *dev; 703 struct cx88_core *core; 704 int err; 705 706 /* general setup */ 707 core = cx88_core_get(pci_dev); 708 if (!core) 709 return -EINVAL; 710 711 pr_info("cx2388x 8802 Driver Manager\n"); 712 713 err = -ENODEV; 714 if (!core->board.mpeg) 715 goto fail_core; 716 717 err = -ENOMEM; 718 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 719 if (!dev) 720 goto fail_core; 721 dev->pci = pci_dev; 722 dev->core = core; 723 724 /* Maintain a reference so cx88-video can query the 8802 device. */ 725 core->dvbdev = dev; 726 727 err = cx8802_init_common(dev); 728 if (err != 0) 729 goto fail_dev; 730 731 INIT_LIST_HEAD(&dev->drvlist); 732 mutex_lock(&cx8802_mutex); 733 list_add_tail(&dev->devlist, &cx8802_devlist); 734 mutex_unlock(&cx8802_mutex); 735 736 /* now autoload cx88-dvb or cx88-blackbird */ 737 request_modules(dev); 738 return 0; 739 740 fail_dev: 741 kfree(dev); 742 fail_core: 743 core->dvbdev = NULL; 744 cx88_core_put(core, pci_dev); 745 return err; 746 } 747 748 static void cx8802_remove(struct pci_dev *pci_dev) 749 { 750 struct cx8802_dev *dev; 751 752 dev = pci_get_drvdata(pci_dev); 753 754 dprintk(1, "%s\n", __func__); 755 756 flush_request_modules(dev); 757 758 mutex_lock(&dev->core->lock); 759 760 if (!list_empty(&dev->drvlist)) { 761 struct cx8802_driver *drv, *tmp; 762 int err; 763 764 pr_warn("Trying to remove cx8802 driver while cx8802 sub-drivers still loaded?!\n"); 765 766 list_for_each_entry_safe(drv, tmp, &dev->drvlist, drvlist) { 767 err = drv->remove(drv); 768 if (err == 0) { 769 list_del(&drv->drvlist); 770 } else 771 pr_err("cx8802 driver remove failed (%d)\n", 772 err); 773 kfree(drv); 774 } 775 } 776 777 mutex_unlock(&dev->core->lock); 778 779 /* Destroy any 8802 reference. */ 780 dev->core->dvbdev = NULL; 781 782 /* common */ 783 cx8802_fini_common(dev); 784 cx88_core_put(dev->core, dev->pci); 785 kfree(dev); 786 } 787 788 static const struct pci_device_id cx8802_pci_tbl[] = { 789 { 790 .vendor = 0x14f1, 791 .device = 0x8802, 792 .subvendor = PCI_ANY_ID, 793 .subdevice = PCI_ANY_ID, 794 }, { 795 /* --- end of list --- */ 796 } 797 }; 798 MODULE_DEVICE_TABLE(pci, cx8802_pci_tbl); 799 800 static struct pci_driver cx8802_pci_driver = { 801 .name = "cx88-mpeg driver manager", 802 .id_table = cx8802_pci_tbl, 803 .probe = cx8802_probe, 804 .remove = cx8802_remove, 805 }; 806 807 module_pci_driver(cx8802_pci_driver); 808