1/* 2 * Driver for the NXP SAA7164 PCIe bridge 3 * 4 * Copyright (c) 2009 Steven Toth <stoth@kernellabs.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22#include <linux/init.h> 23#include <linux/list.h> 24#include <linux/module.h> 25#include <linux/moduleparam.h> 26#include <linux/kmod.h> 27#include <linux/kernel.h> 28#include <linux/slab.h> 29#include <linux/interrupt.h> 30#include <linux/delay.h> 31#include <asm/div64.h> 32 33#include "saa7164.h" 34 35MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards"); 36MODULE_AUTHOR("Steven Toth <stoth@kernellabs.com>"); 37MODULE_LICENSE("GPL"); 38 39/* 40 1 Basic 41 2 42 4 i2c 43 8 api 44 16 cmd 45 32 bus 46 */ 47 48unsigned int saa_debug; 49module_param_named(debug, saa_debug, int, 0644); 50MODULE_PARM_DESC(debug, "enable debug messages"); 51 52unsigned int waitsecs = 10; 53module_param(waitsecs, int, 0644); 54MODULE_PARM_DESC(debug, "timeout on firmware messages"); 55 56static unsigned int card[] = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET }; 57module_param_array(card, int, NULL, 0444); 58MODULE_PARM_DESC(card, "card type"); 59 60static unsigned int saa7164_devcount; 61 62static DEFINE_MUTEX(devlist); 63LIST_HEAD(saa7164_devlist); 64 65#define INT_SIZE 16 66 67static void saa7164_work_cmdhandler(struct work_struct *w) 68{ 69 struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd); 70 71 /* Wake up any complete commands */ 72 saa7164_irq_dequeue(dev); 73} 74 75static void saa7164_buffer_deliver(struct saa7164_buffer *buf) 76{ 77 struct saa7164_tsport *port = buf->port; 78 79 /* Feed the transport payload into the kernel demux */ 80 dvb_dmx_swfilter_packets(&port->dvb.demux, (u8 *)buf->cpu, 81 SAA7164_TS_NUMBER_OF_LINES); 82 83} 84 85static irqreturn_t saa7164_irq_ts(struct saa7164_tsport *port) 86{ 87 struct saa7164_dev *dev = port->dev; 88 struct saa7164_buffer *buf; 89 struct list_head *c, *n; 90 int wp, i = 0, rp; 91 92 /* Find the current write point from the hardware */ 93 wp = saa7164_readl(port->bufcounter); 94 if (wp > (port->hwcfg.buffercount - 1)) 95 BUG(); 96 97 /* Find the previous buffer to the current write point */ 98 if (wp == 0) 99 rp = 7; 100 else 101 rp = wp - 1; 102 103 /* Lookup the WP in the buffer list */ 104 /* TODO: turn this into a worker thread */ 105 list_for_each_safe(c, n, &port->dmaqueue.list) { 106 buf = list_entry(c, struct saa7164_buffer, list); 107 if (i++ > port->hwcfg.buffercount) 108 BUG(); 109 110 if (buf->nr == rp) { 111 /* Found the buffer, deal with it */ 112 dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n", 113 __func__, wp, rp); 114 saa7164_buffer_deliver(buf); 115 break; 116 } 117 118 } 119 return 0; 120} 121 122/* Primary IRQ handler and dispatch mechanism */ 123static irqreturn_t saa7164_irq(int irq, void *dev_id) 124{ 125 struct saa7164_dev *dev = dev_id; 126 u32 intid, intstat[INT_SIZE/4]; 127 int i, handled = 0, bit; 128 129 if (dev == 0) { 130 printk(KERN_ERR "%s() No device specified\n", __func__); 131 handled = 0; 132 goto out; 133 } 134 135 /* Check that the hardware is accessable. If the status bytes are 136 * 0xFF then the device is not accessable, the the IRQ belongs 137 * to another driver. 138 * 4 x u32 interrupt registers. 139 */ 140 for (i = 0; i < INT_SIZE/4; i++) { 141 142 /* TODO: Convert into saa7164_readl() */ 143 /* Read the 4 hardware interrupt registers */ 144 intstat[i] = saa7164_readl(dev->int_status + (i * 4)); 145 146 if (intstat[i]) 147 handled = 1; 148 } 149 if (handled == 0) 150 goto out; 151 152 /* For each of the HW interrupt registers */ 153 for (i = 0; i < INT_SIZE/4; i++) { 154 155 if (intstat[i]) { 156 /* Each function of the board has it's own interruptid. 157 * Find the function that triggered then call 158 * it's handler. 159 */ 160 for (bit = 0; bit < 32; bit++) { 161 162 if (((intstat[i] >> bit) & 0x00000001) == 0) 163 continue; 164 165 /* Calculate the interrupt id (0x00 to 0x7f) */ 166 167 intid = (i * 32) + bit; 168 if (intid == dev->intfdesc.bInterruptId) { 169 /* A response to an cmd/api call */ 170 schedule_work(&dev->workcmd); 171 } else if (intid == 172 dev->ts1.hwcfg.interruptid) { 173 174 /* Transport path 1 */ 175 saa7164_irq_ts(&dev->ts1); 176 177 } else if (intid == 178 dev->ts2.hwcfg.interruptid) { 179 180 /* Transport path 2 */ 181 saa7164_irq_ts(&dev->ts2); 182 183 } else { 184 /* Find the function */ 185 dprintk(DBGLVL_IRQ, 186 "%s() unhandled interrupt " 187 "reg 0x%x bit 0x%x " 188 "intid = 0x%x\n", 189 __func__, i, bit, intid); 190 } 191 } 192 193 /* Ack it */ 194 saa7164_writel(dev->int_ack + (i * 4), intstat[i]); 195 196 } 197 } 198out: 199 return IRQ_RETVAL(handled); 200} 201 202void saa7164_getfirmwarestatus(struct saa7164_dev *dev) 203{ 204 struct saa7164_fw_status *s = &dev->fw_status; 205 206 dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS); 207 dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE); 208 dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC); 209 dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST); 210 dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD); 211 dev->fw_status.remainheap = 212 saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP); 213 214 dprintk(1, "Firmware status:\n"); 215 dprintk(1, " .status = 0x%08x\n", s->status); 216 dprintk(1, " .mode = 0x%08x\n", s->mode); 217 dprintk(1, " .spec = 0x%08x\n", s->spec); 218 dprintk(1, " .inst = 0x%08x\n", s->inst); 219 dprintk(1, " .cpuload = 0x%08x\n", s->cpuload); 220 dprintk(1, " .remainheap = 0x%08x\n", s->remainheap); 221} 222 223u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev) 224{ 225 u32 reg; 226 227 reg = saa7164_readl(SAA_DEVICE_VERSION); 228 dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n", 229 (reg & 0x0000fc00) >> 10, 230 (reg & 0x000003e0) >> 5, 231 (reg & 0x0000001f), 232 (reg & 0xffff0000) >> 16, 233 reg); 234 235 return reg; 236} 237 238/* TODO: Debugging func, remove */ 239void saa7164_dumphex16(struct saa7164_dev *dev, u8 *buf, int len) 240{ 241 int i; 242 243 printk(KERN_INFO "--------------------> " 244 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); 245 246 for (i = 0; i < len; i += 16) 247 printk(KERN_INFO " [0x%08x] " 248 "%02x %02x %02x %02x %02x %02x %02x %02x " 249 "%02x %02x %02x %02x %02x %02x %02x %02x\n", i, 250 *(buf+i+0), *(buf+i+1), *(buf+i+2), *(buf+i+3), 251 *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7), 252 *(buf+i+8), *(buf+i+9), *(buf+i+10), *(buf+i+11), 253 *(buf+i+12), *(buf+i+13), *(buf+i+14), *(buf+i+15)); 254} 255 256/* TODO: Debugging func, remove */ 257void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr) 258{ 259 int i; 260 261 dprintk(1, "--------------------> " 262 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n"); 263 264 for (i = 0; i < 0x100; i += 16) 265 dprintk(1, "region0[0x%08x] = " 266 "%02x %02x %02x %02x %02x %02x %02x %02x" 267 " %02x %02x %02x %02x %02x %02x %02x %02x\n", i, 268 (u8)saa7164_readb(addr + i + 0), 269 (u8)saa7164_readb(addr + i + 1), 270 (u8)saa7164_readb(addr + i + 2), 271 (u8)saa7164_readb(addr + i + 3), 272 (u8)saa7164_readb(addr + i + 4), 273 (u8)saa7164_readb(addr + i + 5), 274 (u8)saa7164_readb(addr + i + 6), 275 (u8)saa7164_readb(addr + i + 7), 276 (u8)saa7164_readb(addr + i + 8), 277 (u8)saa7164_readb(addr + i + 9), 278 (u8)saa7164_readb(addr + i + 10), 279 (u8)saa7164_readb(addr + i + 11), 280 (u8)saa7164_readb(addr + i + 12), 281 (u8)saa7164_readb(addr + i + 13), 282 (u8)saa7164_readb(addr + i + 14), 283 (u8)saa7164_readb(addr + i + 15) 284 ); 285} 286 287static void saa7164_dump_hwdesc(struct saa7164_dev *dev) 288{ 289 dprintk(1, "@0x%p hwdesc sizeof(tmComResHWDescr_t) = %d bytes\n", 290 &dev->hwdesc, (u32)sizeof(tmComResHWDescr_t)); 291 292 dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength); 293 dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType); 294 dprintk(1, " .bDescriptorSubtype = 0x%x\n", 295 dev->hwdesc.bDescriptorSubtype); 296 297 dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion); 298 dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency); 299 dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes); 300 dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities); 301 dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n", 302 dev->hwdesc.dwDeviceRegistersLocation); 303 304 dprintk(1, " .dwHostMemoryRegion = 0x%x\n", 305 dev->hwdesc.dwHostMemoryRegion); 306 307 dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n", 308 dev->hwdesc.dwHostMemoryRegionSize); 309 310 dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n", 311 dev->hwdesc.dwHostHibernatMemRegion); 312 313 dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n", 314 dev->hwdesc.dwHostHibernatMemRegionSize); 315} 316 317static void saa7164_dump_intfdesc(struct saa7164_dev *dev) 318{ 319 dprintk(1, "@0x%p intfdesc " 320 "sizeof(tmComResInterfaceDescr_t) = %d bytes\n", 321 &dev->intfdesc, (u32)sizeof(tmComResInterfaceDescr_t)); 322 323 dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength); 324 dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType); 325 dprintk(1, " .bDescriptorSubtype = 0x%x\n", 326 dev->intfdesc.bDescriptorSubtype); 327 328 dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags); 329 dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType); 330 dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId); 331 dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface); 332 dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId); 333 dprintk(1, " .bDebugInterruptId = 0x%x\n", 334 dev->intfdesc.bDebugInterruptId); 335 336 dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation); 337} 338 339static void saa7164_dump_busdesc(struct saa7164_dev *dev) 340{ 341 dprintk(1, "@0x%p busdesc sizeof(tmComResBusDescr_t) = %d bytes\n", 342 &dev->busdesc, (u32)sizeof(tmComResBusDescr_t)); 343 344 dprintk(1, " .CommandRing = 0x%016Lx\n", dev->busdesc.CommandRing); 345 dprintk(1, " .ResponseRing = 0x%016Lx\n", dev->busdesc.ResponseRing); 346 dprintk(1, " .CommandWrite = 0x%x\n", dev->busdesc.CommandWrite); 347 dprintk(1, " .CommandRead = 0x%x\n", dev->busdesc.CommandRead); 348 dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite); 349 dprintk(1, " .ResponseRead = 0x%x\n", dev->busdesc.ResponseRead); 350} 351 352/* Much of the hardware configuration and PCI registers are configured 353 * dynamically depending on firmware. We have to cache some initial 354 * structures then use these to locate other important structures 355 * from PCI space. 356 */ 357static void saa7164_get_descriptors(struct saa7164_dev *dev) 358{ 359 memcpy(&dev->hwdesc, dev->bmmio, sizeof(tmComResHWDescr_t)); 360 memcpy(&dev->intfdesc, dev->bmmio + sizeof(tmComResHWDescr_t), 361 sizeof(tmComResInterfaceDescr_t)); 362 memcpy(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation, 363 sizeof(tmComResBusDescr_t)); 364 365 if (dev->hwdesc.bLength != sizeof(tmComResHWDescr_t)) { 366 printk(KERN_ERR "Structure tmComResHWDescr_t is mangled\n"); 367 printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength, 368 (u32)sizeof(tmComResHWDescr_t)); 369 } else 370 saa7164_dump_hwdesc(dev); 371 372 if (dev->intfdesc.bLength != sizeof(tmComResInterfaceDescr_t)) { 373 printk(KERN_ERR "struct tmComResInterfaceDescr_t is mangled\n"); 374 printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength, 375 (u32)sizeof(tmComResInterfaceDescr_t)); 376 } else 377 saa7164_dump_intfdesc(dev); 378 379 saa7164_dump_busdesc(dev); 380} 381 382static int saa7164_pci_quirks(struct saa7164_dev *dev) 383{ 384 return 0; 385} 386 387static int get_resources(struct saa7164_dev *dev) 388{ 389 if (request_mem_region(pci_resource_start(dev->pci, 0), 390 pci_resource_len(dev->pci, 0), dev->name)) { 391 392 if (request_mem_region(pci_resource_start(dev->pci, 2), 393 pci_resource_len(dev->pci, 2), dev->name)) 394 return 0; 395 } 396 397 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n", 398 dev->name, 399 (u64)pci_resource_start(dev->pci, 0), 400 (u64)pci_resource_start(dev->pci, 2)); 401 402 return -EBUSY; 403} 404 405static int saa7164_dev_setup(struct saa7164_dev *dev) 406{ 407 int i; 408 409 mutex_init(&dev->lock); 410 atomic_inc(&dev->refcount); 411 dev->nr = saa7164_devcount++; 412 413 sprintf(dev->name, "saa7164[%d]", dev->nr); 414 415 mutex_lock(&devlist); 416 list_add_tail(&dev->devlist, &saa7164_devlist); 417 mutex_unlock(&devlist); 418 419 /* board config */ 420 dev->board = UNSET; 421 if (card[dev->nr] < saa7164_bcount) 422 dev->board = card[dev->nr]; 423 424 for (i = 0; UNSET == dev->board && i < saa7164_idcount; i++) 425 if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor && 426 dev->pci->subsystem_device == 427 saa7164_subids[i].subdevice) 428 dev->board = saa7164_subids[i].card; 429 430 if (UNSET == dev->board) { 431 dev->board = SAA7164_BOARD_UNKNOWN; 432 saa7164_card_list(dev); 433 } 434 435 dev->pci_bus = dev->pci->bus->number; 436 dev->pci_slot = PCI_SLOT(dev->pci->devfn); 437 438 /* I2C Defaults / setup */ 439 dev->i2c_bus[0].dev = dev; 440 dev->i2c_bus[0].nr = 0; 441 dev->i2c_bus[1].dev = dev; 442 dev->i2c_bus[1].nr = 1; 443 dev->i2c_bus[2].dev = dev; 444 dev->i2c_bus[2].nr = 2; 445 446 /* Transport port A Defaults / setup */ 447 dev->ts1.dev = dev; 448 dev->ts1.nr = 0; 449 mutex_init(&dev->ts1.dvb.lock); 450 INIT_LIST_HEAD(&dev->ts1.dmaqueue.list); 451 INIT_LIST_HEAD(&dev->ts1.dummy_dmaqueue.list); 452 mutex_init(&dev->ts1.dmaqueue_lock); 453 mutex_init(&dev->ts1.dummy_dmaqueue_lock); 454 455 /* Transport port B Defaults / setup */ 456 dev->ts2.dev = dev; 457 dev->ts2.nr = 1; 458 mutex_init(&dev->ts2.dvb.lock); 459 INIT_LIST_HEAD(&dev->ts2.dmaqueue.list); 460 INIT_LIST_HEAD(&dev->ts2.dummy_dmaqueue.list); 461 mutex_init(&dev->ts2.dmaqueue_lock); 462 mutex_init(&dev->ts2.dummy_dmaqueue_lock); 463 464 if (get_resources(dev) < 0) { 465 printk(KERN_ERR "CORE %s No more PCIe resources for " 466 "subsystem: %04x:%04x\n", 467 dev->name, dev->pci->subsystem_vendor, 468 dev->pci->subsystem_device); 469 470 saa7164_devcount--; 471 return -ENODEV; 472 } 473 474 /* PCI/e allocations */ 475 dev->lmmio = ioremap(pci_resource_start(dev->pci, 0), 476 pci_resource_len(dev->pci, 0)); 477 478 dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2), 479 pci_resource_len(dev->pci, 2)); 480 481 dev->bmmio = (u8 __iomem *)dev->lmmio; 482 dev->bmmio2 = (u8 __iomem *)dev->lmmio2; 483 484 /* Inerrupt and ack register locations offset of bmmio */ 485 dev->int_status = 0x183000 + 0xf80; 486 dev->int_ack = 0x183000 + 0xf90; 487 488 printk(KERN_INFO 489 "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n", 490 dev->name, dev->pci->subsystem_vendor, 491 dev->pci->subsystem_device, saa7164_boards[dev->board].name, 492 dev->board, card[dev->nr] == dev->board ? 493 "insmod option" : "autodetected"); 494 495 saa7164_pci_quirks(dev); 496 497 return 0; 498} 499 500static void saa7164_dev_unregister(struct saa7164_dev *dev) 501{ 502 dprintk(1, "%s()\n", __func__); 503 504 release_mem_region(pci_resource_start(dev->pci, 0), 505 pci_resource_len(dev->pci, 0)); 506 507 release_mem_region(pci_resource_start(dev->pci, 2), 508 pci_resource_len(dev->pci, 2)); 509 510 if (!atomic_dec_and_test(&dev->refcount)) 511 return; 512 513 iounmap(dev->lmmio); 514 iounmap(dev->lmmio2); 515 516 return; 517} 518 519static int __devinit saa7164_initdev(struct pci_dev *pci_dev, 520 const struct pci_device_id *pci_id) 521{ 522 struct saa7164_dev *dev; 523 int err, i; 524 u32 version; 525 526 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 527 if (NULL == dev) 528 return -ENOMEM; 529 530 /* pci init */ 531 dev->pci = pci_dev; 532 if (pci_enable_device(pci_dev)) { 533 err = -EIO; 534 goto fail_free; 535 } 536 537 if (saa7164_dev_setup(dev) < 0) { 538 err = -EINVAL; 539 goto fail_free; 540 } 541 542 /* print pci info */ 543 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev); 544 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat); 545 printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, " 546 "latency: %d, mmio: 0x%llx\n", dev->name, 547 pci_name(pci_dev), dev->pci_rev, pci_dev->irq, 548 dev->pci_lat, 549 (unsigned long long)pci_resource_start(pci_dev, 0)); 550 551 pci_set_master(pci_dev); 552 /* TODO */ 553 if (!pci_dma_supported(pci_dev, 0xffffffff)) { 554 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name); 555 err = -EIO; 556 goto fail_irq; 557 } 558 559 err = request_irq(pci_dev->irq, saa7164_irq, 560 IRQF_SHARED | IRQF_DISABLED, dev->name, dev); 561 if (err < 0) { 562 printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name, 563 pci_dev->irq); 564 err = -EIO; 565 goto fail_irq; 566 } 567 568 pci_set_drvdata(pci_dev, dev); 569 570 /* Init the internal command list */ 571 for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) { 572 dev->cmds[i].seqno = i; 573 dev->cmds[i].inuse = 0; 574 mutex_init(&dev->cmds[i].lock); 575 init_waitqueue_head(&dev->cmds[i].wait); 576 } 577 578 /* We need a deferred interrupt handler for cmd handling */ 579 INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler); 580 581 /* Only load the firmware if we know the board */ 582 if (dev->board != SAA7164_BOARD_UNKNOWN) { 583 584 err = saa7164_downloadfirmware(dev); 585 if (err < 0) { 586 printk(KERN_ERR 587 "Failed to boot firmware, no features " 588 "registered\n"); 589 goto fail_fw; 590 } 591 592 saa7164_get_descriptors(dev); 593 saa7164_dumpregs(dev, 0); 594 saa7164_getcurrentfirmwareversion(dev); 595 saa7164_getfirmwarestatus(dev); 596 err = saa7164_bus_setup(dev); 597 if (err < 0) 598 printk(KERN_ERR 599 "Failed to setup the bus, will continue\n"); 600 saa7164_bus_dump(dev); 601 602 /* Ping the running firmware via the command bus and get the 603 * firmware version, this checks the bus is running OK. 604 */ 605 version = 0; 606 if (saa7164_api_get_fw_version(dev, &version) == SAA_OK) 607 dprintk(1, "Bus is operating correctly using " 608 "version %d.%d.%d.%d (0x%x)\n", 609 (version & 0x0000fc00) >> 10, 610 (version & 0x000003e0) >> 5, 611 (version & 0x0000001f), 612 (version & 0xffff0000) >> 16, 613 version); 614 else 615 printk(KERN_ERR 616 "Failed to communicate with the firmware\n"); 617 618 /* Bring up the I2C buses */ 619 saa7164_i2c_register(&dev->i2c_bus[0]); 620 saa7164_i2c_register(&dev->i2c_bus[1]); 621 saa7164_i2c_register(&dev->i2c_bus[2]); 622 saa7164_gpio_setup(dev); 623 saa7164_card_setup(dev); 624 625 626 /* Parse the dynamic device configuration, find various 627 * media endpoints (MPEG, WMV, PS, TS) and cache their 628 * configuration details into the driver, so we can 629 * reference them later during simething_register() func, 630 * interrupt handlers, deferred work handlers etc. 631 */ 632 saa7164_api_enum_subdevs(dev); 633 634 /* Begin to create the video sub-systems and register funcs */ 635 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) { 636 if (saa7164_dvb_register(&dev->ts1) < 0) { 637 printk(KERN_ERR "%s() Failed to register " 638 "dvb adapters on porta\n", 639 __func__); 640 } 641 } 642 643 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) { 644 if (saa7164_dvb_register(&dev->ts2) < 0) { 645 printk(KERN_ERR"%s() Failed to register " 646 "dvb adapters on portb\n", 647 __func__); 648 } 649 } 650 651 } /* != BOARD_UNKNOWN */ 652 else 653 printk(KERN_ERR "%s() Unsupported board detected, " 654 "registering without firmware\n", __func__); 655 656 dprintk(1, "%s() parameter debug = %d\n", __func__, saa_debug); 657 dprintk(1, "%s() parameter waitsecs = %d\n", __func__, waitsecs); 658 659fail_fw: 660 return 0; 661 662fail_irq: 663 saa7164_dev_unregister(dev); 664fail_free: 665 kfree(dev); 666 return err; 667} 668 669static void saa7164_shutdown(struct saa7164_dev *dev) 670{ 671 dprintk(1, "%s()\n", __func__); 672} 673 674static void __devexit saa7164_finidev(struct pci_dev *pci_dev) 675{ 676 struct saa7164_dev *dev = pci_get_drvdata(pci_dev); 677 678 saa7164_shutdown(dev); 679 680 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) 681 saa7164_dvb_unregister(&dev->ts1); 682 683 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) 684 saa7164_dvb_unregister(&dev->ts2); 685 686 saa7164_i2c_unregister(&dev->i2c_bus[0]); 687 saa7164_i2c_unregister(&dev->i2c_bus[1]); 688 saa7164_i2c_unregister(&dev->i2c_bus[2]); 689 690 pci_disable_device(pci_dev); 691 692 /* unregister stuff */ 693 free_irq(pci_dev->irq, dev); 694 pci_set_drvdata(pci_dev, NULL); 695 696 mutex_lock(&devlist); 697 list_del(&dev->devlist); 698 mutex_unlock(&devlist); 699 700 saa7164_dev_unregister(dev); 701 kfree(dev); 702} 703 704static struct pci_device_id saa7164_pci_tbl[] = { 705 { 706 /* SAA7164 */ 707 .vendor = 0x1131, 708 .device = 0x7164, 709 .subvendor = PCI_ANY_ID, 710 .subdevice = PCI_ANY_ID, 711 }, { 712 /* --- end of list --- */ 713 } 714}; 715MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl); 716 717static struct pci_driver saa7164_pci_driver = { 718 .name = "saa7164", 719 .id_table = saa7164_pci_tbl, 720 .probe = saa7164_initdev, 721 .remove = __devexit_p(saa7164_finidev), 722 /* TODO */ 723 .suspend = NULL, 724 .resume = NULL, 725}; 726 727static int __init saa7164_init(void) 728{ 729 printk(KERN_INFO "saa7164 driver loaded\n"); 730 return pci_register_driver(&saa7164_pci_driver); 731} 732 733static void __exit saa7164_fini(void) 734{ 735 pci_unregister_driver(&saa7164_pci_driver); 736} 737 738module_init(saa7164_init); 739module_exit(saa7164_fini); 740