1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 saa7146.o - driver for generic saa7146-based hardware 4 5 Copyright (C) 1998-2003 Michael Hunold <michael@mihu.de> 6 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <media/drv-intf/saa7146.h> 12 #include <linux/module.h> 13 14 static int saa7146_num; 15 16 unsigned int saa7146_debug; 17 18 module_param(saa7146_debug, uint, 0644); 19 MODULE_PARM_DESC(saa7146_debug, "debug level (default: 0)"); 20 21 #if 0 22 static void dump_registers(struct saa7146_dev* dev) 23 { 24 int i = 0; 25 26 pr_info(" @ %li jiffies:\n", jiffies); 27 for (i = 0; i <= 0x148; i += 4) 28 pr_info("0x%03x: 0x%08x\n", i, saa7146_read(dev, i)); 29 } 30 #endif 31 32 /**************************************************************************** 33 * gpio and debi helper functions 34 ****************************************************************************/ 35 36 void saa7146_setgpio(struct saa7146_dev *dev, int port, u32 data) 37 { 38 u32 value = 0; 39 40 BUG_ON(port > 3); 41 42 value = saa7146_read(dev, GPIO_CTRL); 43 value &= ~(0xff << (8*port)); 44 value |= (data << (8*port)); 45 saa7146_write(dev, GPIO_CTRL, value); 46 } 47 48 /* This DEBI code is based on the saa7146 Stradis driver by Nathan Laredo */ 49 static inline int saa7146_wait_for_debi_done_sleep(struct saa7146_dev *dev, 50 unsigned long us1, unsigned long us2) 51 { 52 unsigned long timeout; 53 int err; 54 55 /* wait for registers to be programmed */ 56 timeout = jiffies + usecs_to_jiffies(us1); 57 while (1) { 58 err = time_after(jiffies, timeout); 59 if (saa7146_read(dev, MC2) & 2) 60 break; 61 if (err) { 62 pr_debug("%s: %s timed out while waiting for registers getting programmed\n", 63 dev->name, __func__); 64 return -ETIMEDOUT; 65 } 66 msleep(1); 67 } 68 69 /* wait for transfer to complete */ 70 timeout = jiffies + usecs_to_jiffies(us2); 71 while (1) { 72 err = time_after(jiffies, timeout); 73 if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S)) 74 break; 75 saa7146_read(dev, MC2); 76 if (err) { 77 DEB_S("%s: %s timed out while waiting for transfer completion\n", 78 dev->name, __func__); 79 return -ETIMEDOUT; 80 } 81 msleep(1); 82 } 83 84 return 0; 85 } 86 87 static inline int saa7146_wait_for_debi_done_busyloop(struct saa7146_dev *dev, 88 unsigned long us1, unsigned long us2) 89 { 90 unsigned long loops; 91 92 /* wait for registers to be programmed */ 93 loops = us1; 94 while (1) { 95 if (saa7146_read(dev, MC2) & 2) 96 break; 97 if (!loops--) { 98 pr_err("%s: %s timed out while waiting for registers getting programmed\n", 99 dev->name, __func__); 100 return -ETIMEDOUT; 101 } 102 udelay(1); 103 } 104 105 /* wait for transfer to complete */ 106 loops = us2 / 5; 107 while (1) { 108 if (!(saa7146_read(dev, PSR) & SPCI_DEBI_S)) 109 break; 110 saa7146_read(dev, MC2); 111 if (!loops--) { 112 DEB_S("%s: %s timed out while waiting for transfer completion\n", 113 dev->name, __func__); 114 return -ETIMEDOUT; 115 } 116 udelay(5); 117 } 118 119 return 0; 120 } 121 122 int saa7146_wait_for_debi_done(struct saa7146_dev *dev, int nobusyloop) 123 { 124 if (nobusyloop) 125 return saa7146_wait_for_debi_done_sleep(dev, 50000, 250000); 126 else 127 return saa7146_wait_for_debi_done_busyloop(dev, 50000, 250000); 128 } 129 130 /**************************************************************************** 131 * general helper functions 132 ****************************************************************************/ 133 134 /* this is videobuf_vmalloc_to_sg() from videobuf-dma-sg.c 135 make sure virt has been allocated with vmalloc_32(), otherwise the BUG() 136 may be triggered on highmem machines */ 137 static struct scatterlist* vmalloc_to_sg(unsigned char *virt, int nr_pages) 138 { 139 struct scatterlist *sglist; 140 struct page *pg; 141 int i; 142 143 sglist = kmalloc_array(nr_pages, sizeof(struct scatterlist), GFP_KERNEL); 144 if (NULL == sglist) 145 return NULL; 146 sg_init_table(sglist, nr_pages); 147 for (i = 0; i < nr_pages; i++, virt += PAGE_SIZE) { 148 pg = vmalloc_to_page(virt); 149 if (NULL == pg) 150 goto err; 151 BUG_ON(PageHighMem(pg)); 152 sg_set_page(&sglist[i], pg, PAGE_SIZE, 0); 153 } 154 return sglist; 155 156 err: 157 kfree(sglist); 158 return NULL; 159 } 160 161 /********************************************************************************/ 162 /* common page table functions */ 163 164 void *saa7146_vmalloc_build_pgtable(struct pci_dev *pci, long length, struct saa7146_pgtable *pt) 165 { 166 int pages = (length+PAGE_SIZE-1)/PAGE_SIZE; 167 void *mem = vmalloc_32(length); 168 int slen = 0; 169 170 if (NULL == mem) 171 goto err_null; 172 173 if (!(pt->slist = vmalloc_to_sg(mem, pages))) 174 goto err_free_mem; 175 176 if (saa7146_pgtable_alloc(pci, pt)) 177 goto err_free_slist; 178 179 pt->nents = pages; 180 slen = pci_map_sg(pci,pt->slist,pt->nents,PCI_DMA_FROMDEVICE); 181 if (0 == slen) 182 goto err_free_pgtable; 183 184 if (0 != saa7146_pgtable_build_single(pci, pt, pt->slist, slen)) 185 goto err_unmap_sg; 186 187 return mem; 188 189 err_unmap_sg: 190 pci_unmap_sg(pci, pt->slist, pt->nents, PCI_DMA_FROMDEVICE); 191 err_free_pgtable: 192 saa7146_pgtable_free(pci, pt); 193 err_free_slist: 194 kfree(pt->slist); 195 pt->slist = NULL; 196 err_free_mem: 197 vfree(mem); 198 err_null: 199 return NULL; 200 } 201 202 void saa7146_vfree_destroy_pgtable(struct pci_dev *pci, void *mem, struct saa7146_pgtable *pt) 203 { 204 pci_unmap_sg(pci, pt->slist, pt->nents, PCI_DMA_FROMDEVICE); 205 saa7146_pgtable_free(pci, pt); 206 kfree(pt->slist); 207 pt->slist = NULL; 208 vfree(mem); 209 } 210 211 void saa7146_pgtable_free(struct pci_dev *pci, struct saa7146_pgtable *pt) 212 { 213 if (NULL == pt->cpu) 214 return; 215 pci_free_consistent(pci, pt->size, pt->cpu, pt->dma); 216 pt->cpu = NULL; 217 } 218 219 int saa7146_pgtable_alloc(struct pci_dev *pci, struct saa7146_pgtable *pt) 220 { 221 __le32 *cpu; 222 dma_addr_t dma_addr = 0; 223 224 cpu = pci_alloc_consistent(pci, PAGE_SIZE, &dma_addr); 225 if (NULL == cpu) { 226 return -ENOMEM; 227 } 228 pt->size = PAGE_SIZE; 229 pt->cpu = cpu; 230 pt->dma = dma_addr; 231 232 return 0; 233 } 234 235 int saa7146_pgtable_build_single(struct pci_dev *pci, struct saa7146_pgtable *pt, 236 struct scatterlist *list, int sglen ) 237 { 238 __le32 *ptr, fill; 239 int nr_pages = 0; 240 int i,p; 241 242 BUG_ON(0 == sglen); 243 BUG_ON(list->offset > PAGE_SIZE); 244 245 /* if we have a user buffer, the first page may not be 246 aligned to a page boundary. */ 247 pt->offset = list->offset; 248 249 ptr = pt->cpu; 250 for (i = 0; i < sglen; i++, list++) { 251 /* 252 pr_debug("i:%d, adr:0x%08x, len:%d, offset:%d\n", 253 i, sg_dma_address(list), sg_dma_len(list), 254 list->offset); 255 */ 256 for (p = 0; p * 4096 < list->length; p++, ptr++) { 257 *ptr = cpu_to_le32(sg_dma_address(list) + p * 4096); 258 nr_pages++; 259 } 260 } 261 262 263 /* safety; fill the page table up with the last valid page */ 264 fill = *(ptr-1); 265 for(i=nr_pages;i<1024;i++) { 266 *ptr++ = fill; 267 } 268 269 /* 270 ptr = pt->cpu; 271 pr_debug("offset: %d\n", pt->offset); 272 for(i=0;i<5;i++) { 273 pr_debug("ptr1 %d: 0x%08x\n", i, ptr[i]); 274 } 275 */ 276 return 0; 277 } 278 279 /********************************************************************************/ 280 /* interrupt handler */ 281 static irqreturn_t interrupt_hw(int irq, void *dev_id) 282 { 283 struct saa7146_dev *dev = dev_id; 284 u32 isr; 285 u32 ack_isr; 286 287 /* read out the interrupt status register */ 288 ack_isr = isr = saa7146_read(dev, ISR); 289 290 /* is this our interrupt? */ 291 if ( 0 == isr ) { 292 /* nope, some other device */ 293 return IRQ_NONE; 294 } 295 296 if (dev->ext) { 297 if (dev->ext->irq_mask & isr) { 298 if (dev->ext->irq_func) 299 dev->ext->irq_func(dev, &isr); 300 isr &= ~dev->ext->irq_mask; 301 } 302 } 303 if (0 != (isr & (MASK_27))) { 304 DEB_INT("irq: RPS0 (0x%08x)\n", isr); 305 if (dev->vv_data && dev->vv_callback) 306 dev->vv_callback(dev,isr); 307 isr &= ~MASK_27; 308 } 309 if (0 != (isr & (MASK_28))) { 310 if (dev->vv_data && dev->vv_callback) 311 dev->vv_callback(dev,isr); 312 isr &= ~MASK_28; 313 } 314 if (0 != (isr & (MASK_16|MASK_17))) { 315 SAA7146_IER_DISABLE(dev, MASK_16|MASK_17); 316 /* only wake up if we expect something */ 317 if (0 != dev->i2c_op) { 318 dev->i2c_op = 0; 319 wake_up(&dev->i2c_wq); 320 } else { 321 u32 psr = saa7146_read(dev, PSR); 322 u32 ssr = saa7146_read(dev, SSR); 323 pr_warn("%s: unexpected i2c irq: isr %08x psr %08x ssr %08x\n", 324 dev->name, isr, psr, ssr); 325 } 326 isr &= ~(MASK_16|MASK_17); 327 } 328 if( 0 != isr ) { 329 ERR("warning: interrupt enabled, but not handled properly.(0x%08x)\n", 330 isr); 331 ERR("disabling interrupt source(s)!\n"); 332 SAA7146_IER_DISABLE(dev,isr); 333 } 334 saa7146_write(dev, ISR, ack_isr); 335 return IRQ_HANDLED; 336 } 337 338 /*********************************************************************************/ 339 /* configuration-functions */ 340 341 static int saa7146_init_one(struct pci_dev *pci, const struct pci_device_id *ent) 342 { 343 struct saa7146_pci_extension_data *pci_ext = (struct saa7146_pci_extension_data *)ent->driver_data; 344 struct saa7146_extension *ext = pci_ext->ext; 345 struct saa7146_dev *dev; 346 int err = -ENOMEM; 347 348 /* clear out mem for sure */ 349 dev = kzalloc(sizeof(struct saa7146_dev), GFP_KERNEL); 350 if (!dev) { 351 ERR("out of memory\n"); 352 goto out; 353 } 354 355 /* create a nice device name */ 356 sprintf(dev->name, "saa7146 (%d)", saa7146_num); 357 358 DEB_EE("pci:%p\n", pci); 359 360 err = pci_enable_device(pci); 361 if (err < 0) { 362 ERR("pci_enable_device() failed\n"); 363 goto err_free; 364 } 365 366 /* enable bus-mastering */ 367 pci_set_master(pci); 368 369 dev->pci = pci; 370 371 /* get chip-revision; this is needed to enable bug-fixes */ 372 dev->revision = pci->revision; 373 374 /* remap the memory from virtual to physical address */ 375 376 err = pci_request_region(pci, 0, "saa7146"); 377 if (err < 0) 378 goto err_disable; 379 380 dev->mem = ioremap(pci_resource_start(pci, 0), 381 pci_resource_len(pci, 0)); 382 if (!dev->mem) { 383 ERR("ioremap() failed\n"); 384 err = -ENODEV; 385 goto err_release; 386 } 387 388 /* we don't do a master reset here anymore, it screws up 389 some boards that don't have an i2c-eeprom for configuration 390 values */ 391 /* 392 saa7146_write(dev, MC1, MASK_31); 393 */ 394 395 /* disable all irqs */ 396 saa7146_write(dev, IER, 0); 397 398 /* shut down all dma transfers and rps tasks */ 399 saa7146_write(dev, MC1, 0x30ff0000); 400 401 /* clear out any rps-signals pending */ 402 saa7146_write(dev, MC2, 0xf8000000); 403 404 /* request an interrupt for the saa7146 */ 405 err = request_irq(pci->irq, interrupt_hw, IRQF_SHARED, 406 dev->name, dev); 407 if (err < 0) { 408 ERR("request_irq() failed\n"); 409 goto err_unmap; 410 } 411 412 err = -ENOMEM; 413 414 /* get memory for various stuff */ 415 dev->d_rps0.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM, 416 &dev->d_rps0.dma_handle); 417 if (!dev->d_rps0.cpu_addr) 418 goto err_free_irq; 419 420 dev->d_rps1.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM, 421 &dev->d_rps1.dma_handle); 422 if (!dev->d_rps1.cpu_addr) 423 goto err_free_rps0; 424 425 dev->d_i2c.cpu_addr = pci_zalloc_consistent(pci, SAA7146_RPS_MEM, 426 &dev->d_i2c.dma_handle); 427 if (!dev->d_i2c.cpu_addr) 428 goto err_free_rps1; 429 430 /* the rest + print status message */ 431 432 pr_info("found saa7146 @ mem %p (revision %d, irq %d) (0x%04x,0x%04x)\n", 433 dev->mem, dev->revision, pci->irq, 434 pci->subsystem_vendor, pci->subsystem_device); 435 dev->ext = ext; 436 437 mutex_init(&dev->v4l2_lock); 438 spin_lock_init(&dev->int_slock); 439 spin_lock_init(&dev->slock); 440 441 mutex_init(&dev->i2c_lock); 442 443 dev->module = THIS_MODULE; 444 init_waitqueue_head(&dev->i2c_wq); 445 446 /* set some sane pci arbitrition values */ 447 saa7146_write(dev, PCI_BT_V1, 0x1c00101f); 448 449 /* TODO: use the status code of the callback */ 450 451 err = -ENODEV; 452 453 if (ext->probe && ext->probe(dev)) { 454 DEB_D("ext->probe() failed for %p. skipping device.\n", dev); 455 goto err_free_i2c; 456 } 457 458 if (ext->attach(dev, pci_ext)) { 459 DEB_D("ext->attach() failed for %p. skipping device.\n", dev); 460 goto err_free_i2c; 461 } 462 /* V4L extensions will set the pci drvdata to the v4l2_device in the 463 attach() above. So for those cards that do not use V4L we have to 464 set it explicitly. */ 465 pci_set_drvdata(pci, &dev->v4l2_dev); 466 467 saa7146_num++; 468 469 err = 0; 470 out: 471 return err; 472 473 err_free_i2c: 474 pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_i2c.cpu_addr, 475 dev->d_i2c.dma_handle); 476 err_free_rps1: 477 pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_rps1.cpu_addr, 478 dev->d_rps1.dma_handle); 479 err_free_rps0: 480 pci_free_consistent(pci, SAA7146_RPS_MEM, dev->d_rps0.cpu_addr, 481 dev->d_rps0.dma_handle); 482 err_free_irq: 483 free_irq(pci->irq, (void *)dev); 484 err_unmap: 485 iounmap(dev->mem); 486 err_release: 487 pci_release_region(pci, 0); 488 err_disable: 489 pci_disable_device(pci); 490 err_free: 491 kfree(dev); 492 goto out; 493 } 494 495 static void saa7146_remove_one(struct pci_dev *pdev) 496 { 497 struct v4l2_device *v4l2_dev = pci_get_drvdata(pdev); 498 struct saa7146_dev *dev = to_saa7146_dev(v4l2_dev); 499 struct { 500 void *addr; 501 dma_addr_t dma; 502 } dev_map[] = { 503 { dev->d_i2c.cpu_addr, dev->d_i2c.dma_handle }, 504 { dev->d_rps1.cpu_addr, dev->d_rps1.dma_handle }, 505 { dev->d_rps0.cpu_addr, dev->d_rps0.dma_handle }, 506 { NULL, 0 } 507 }, *p; 508 509 DEB_EE("dev:%p\n", dev); 510 511 dev->ext->detach(dev); 512 513 /* shut down all video dma transfers */ 514 saa7146_write(dev, MC1, 0x00ff0000); 515 516 /* disable all irqs, release irq-routine */ 517 saa7146_write(dev, IER, 0); 518 519 free_irq(pdev->irq, dev); 520 521 for (p = dev_map; p->addr; p++) 522 pci_free_consistent(pdev, SAA7146_RPS_MEM, p->addr, p->dma); 523 524 iounmap(dev->mem); 525 pci_release_region(pdev, 0); 526 pci_disable_device(pdev); 527 kfree(dev); 528 529 saa7146_num--; 530 } 531 532 /*********************************************************************************/ 533 /* extension handling functions */ 534 535 int saa7146_register_extension(struct saa7146_extension* ext) 536 { 537 DEB_EE("ext:%p\n", ext); 538 539 ext->driver.name = ext->name; 540 ext->driver.id_table = ext->pci_tbl; 541 ext->driver.probe = saa7146_init_one; 542 ext->driver.remove = saa7146_remove_one; 543 544 pr_info("register extension '%s'\n", ext->name); 545 return pci_register_driver(&ext->driver); 546 } 547 548 int saa7146_unregister_extension(struct saa7146_extension* ext) 549 { 550 DEB_EE("ext:%p\n", ext); 551 pr_info("unregister extension '%s'\n", ext->name); 552 pci_unregister_driver(&ext->driver); 553 return 0; 554 } 555 556 EXPORT_SYMBOL_GPL(saa7146_register_extension); 557 EXPORT_SYMBOL_GPL(saa7146_unregister_extension); 558 559 /* misc functions used by extension modules */ 560 EXPORT_SYMBOL_GPL(saa7146_pgtable_alloc); 561 EXPORT_SYMBOL_GPL(saa7146_pgtable_free); 562 EXPORT_SYMBOL_GPL(saa7146_pgtable_build_single); 563 EXPORT_SYMBOL_GPL(saa7146_vmalloc_build_pgtable); 564 EXPORT_SYMBOL_GPL(saa7146_vfree_destroy_pgtable); 565 EXPORT_SYMBOL_GPL(saa7146_wait_for_debi_done); 566 567 EXPORT_SYMBOL_GPL(saa7146_setgpio); 568 569 EXPORT_SYMBOL_GPL(saa7146_i2c_adapter_prepare); 570 571 EXPORT_SYMBOL_GPL(saa7146_debug); 572 573 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>"); 574 MODULE_DESCRIPTION("driver for generic saa7146-based hardware"); 575 MODULE_LICENSE("GPL"); 576