drivers/media/common/saa7146_core.c

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