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