/* * bt878.c: part of the driver for the Pinnacle PCTV Sat DVB PCI card * * Copyright (C) 2002 Peter Hettkamp * * large parts based on the bttv driver * Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de) * & Marcus Metzler (mocm@thp.uni-koeln.de) * (c) 1999,2000 Gerd Knorr * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Or, point your browser to http://www.gnu.org/copyleft/gpl.html * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "bt878.h" /**************************************/ /* Miscellaneous utility definitions */ /**************************************/ unsigned int bt878_verbose = 1; unsigned int bt878_debug = 0; MODULE_PARM(bt878_verbose,"i"); MODULE_PARM_DESC(bt878_verbose,"verbose startup messages, default is 1 (yes)"); MODULE_PARM(bt878_debug,"i"); MODULE_PARM_DESC(bt878_debug,"debug messages, default is 0 (no)"); int bt878_num; struct bt878 bt878[BT878_MAX]; EXPORT_SYMBOL(bt878_num); EXPORT_SYMBOL(bt878); #if defined(__powerpc__) /* big-endian */ extern __inline__ void io_st_le32(volatile unsigned *addr, unsigned val) { __asm__ __volatile__ ("stwbrx %1,0,%2" : \ "=m" (*addr) : "r" (val), "r" (addr)); __asm__ __volatile__ ("eieio" : : : "memory"); } #define btwrite(dat,adr) io_st_le32((unsigned *)(bt->bt878_mem+(adr)),(dat)) #define btread(adr) ld_le32((unsigned *)(bt->bt878_mem+(adr))) #else #define btwrite(dat,adr) writel((dat), (char *) (bt->bt878_mem+(adr))) #define btread(adr) readl(bt->bt878_mem+(adr)) #endif #define btand(dat,adr) btwrite((dat) & btread(adr), adr) #define btor(dat,adr) btwrite((dat) | btread(adr), adr) #define btaor(dat,mask,adr) btwrite((dat) | ((mask) & btread(adr)), adr) #if defined(dprintk) #undef dprintk #endif #define dprintk if(bt878_debug) printk /*******************************/ /* Memory management functions */ /*******************************/ #define MDEBUG(x) do { } while(0) /* Debug memory management */ /* All taken from [DaveM] from the bttv driver * I will not pretend that I understand this, but * it seems to work. * * The code used to assume that the kernel vmalloc mappings * existed in the page tables of every process, this is simply * not guarenteed. We now use pgd_offset_k which is the * defined way to get at the kernel page tables. */ /* Given PGD from the address space's page table, return the kernel * virtual mapping of the physical memory mapped at ADR. */ static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr) { unsigned long ret = 0UL; pmd_t *pmd; pte_t *ptep, pte; if (!pgd_none(*pgd)) { pmd = pmd_offset(pgd, adr); if (!pmd_none(*pmd)) { ptep = pte_offset(pmd, adr); pte = *ptep; if(pte_present(pte)) { ret = (unsigned long) page_address(pte_page(pte)); ret |= (adr & (PAGE_SIZE - 1)); } } } MDEBUG(printk("uv2kva(%lx-->%lx)", adr, ret)); return ret; } static inline unsigned long uvirt_to_bus(unsigned long adr) { unsigned long kva, ret; kva = uvirt_to_kva(pgd_offset(current->mm, adr), adr); ret = virt_to_bus((void *)kva); MDEBUG(printk("uv2b(%lx-->%lx)", adr, ret)); return ret; } static inline unsigned long kvirt_to_bus(unsigned long adr) { unsigned long va, kva, ret; va = VMALLOC_VMADDR(adr); kva = uvirt_to_kva(pgd_offset_k(va), va); ret = virt_to_bus((void *)kva); MDEBUG(printk("kv2b(%lx-->%lx)", adr, ret)); return ret; } /* Here we want the physical address of the memory. * This is used when initializing the contents of the * area and marking the pages as reserved. */ static inline unsigned long kvirt_to_pa(unsigned long adr) { unsigned long va, kva, ret; va = VMALLOC_VMADDR(adr); kva = uvirt_to_kva(pgd_offset_k(va), va); ret = __pa(kva); MDEBUG(printk("kv2pa(%lx-->%lx)", adr, ret)); return ret; } static void * rvmalloc(signed long size) { void * mem; unsigned long adr, page; mem=vmalloc_32(size); if (mem) { memset(mem, 0, size); /* Clear the ram out, no junk to the user */ adr=(unsigned long) mem; while (size > 0) { page = kvirt_to_pa(adr); mem_map_reserve(virt_to_page(__va(page))); adr+=PAGE_SIZE; size-=PAGE_SIZE; } } return mem; } static void rvfree(void * mem, signed long size) { unsigned long adr, page; if (mem) { adr=(unsigned long) mem; while (size > 0) { page = kvirt_to_pa(adr); mem_map_unreserve(virt_to_page(__va(page))); adr+=PAGE_SIZE; size-=PAGE_SIZE; } vfree(mem); } } /*****************************/ /* Buffer setup function(s) */ /*****************************/ int bt878_get_buffers(struct bt878 *bt, int bpl, int lpf, int nbufs, int sync) { /* try to allocate nbufs buffers, 2<=nbufs<=16. Each buffer is a "frame" bpl bytes wide and lpf lines high. The buffers will be contiguous in kernel virtual space, but will consist of discontinuous physical pages. Set up a DMA program to read all these buffers in sequence, and generate an interrupt at the start of each buffer. if sync==1, insert a sync RISC op at the start of each buffer, else don't. */ unsigned long *pc, *pc2; unsigned char *bp; int i, j, size, rest; unsigned long op; dprintk("bt878 debug: bt878_get_buffers(%p, bpl=0x%x, lpf=0x%x, n=0x%x\n",bt,bpl,lpf,nbufs); if(nbufs<2||nbufs>16) return -EINVAL; if(bpl<0||bpl>4095) return -EINVAL; if(lpf*nbufs<0||lpf*nbufs>255) return -EINVAL; if(!bt) return -ENXIO; /* stop a possibly running DMA operation */ btand(~0x0f,BT878_AGPIO_DMA_CTL); i=btread(BT878_AGPIO_DMA_CTL); if(bt->buffer) {rvfree(bt->buffer,bt->allocbufsize); bt->buffer=0; } if(bt->riscprog) {rvfree(bt->riscprog,PAGE_SIZE); bt->riscprog=0;} bt->framesize=bpl*lpf; bt->buffersize=bt->framesize*nbufs; bt->allocbufsize=(bpl*lpf*nbufs); if(bt->allocbufsize&~PAGE_MASK) bt->allocbufsize=(bt->allocbufsize&PAGE_MASK)+PAGE_SIZE; dprintk("bt878 debug: allocating 0x%x bytes (min was 0x%x)\n",bt->allocbufsize,(bpl*lpf*nbufs)); if(!(bt->buffer=rvmalloc(bt->allocbufsize))) { return -ENOMEM; } if(!(bt->riscprog=rvmalloc(PAGE_SIZE))) { goto fail1; } dprintk("bt878 debug: buffer=%p, riscprog=%p\n",bt->buffer,bt->riscprog); /* ok. We have the memory for the buffers. Let us set up the DMA prog */ pc=bt->riscprog; bp=bt->buffer; /* sync operation at the beginning of the program */ *pc++=cpu_to_le32(BT848_RISC_SYNC|BT848_RISC_RESYNC| BT848_FIFO_STATUS_FM1|(0xf<<20)); *pc++=0; for(i=0;iriscprog)*sizeof(long)>PAGE_SIZE) goto fail2; } } if(sync) { *pc++=cpu_to_le32(BT848_RISC_SYNC|BT848_RISC_RESYNC| BT848_FIFO_STATUS_FM1); *pc++=0; } } *pc++=cpu_to_le32(BT848_RISC_JUMP); *pc++=cpu_to_le32(kvirt_to_bus((unsigned long)bt->riscprog)); btwrite(cpu_to_le32(bpl|((lpf*nbufs)<<16)),BT878_APACK_LEN); btwrite(cpu_to_le32(kvirt_to_bus((unsigned long)bt->riscprog)),BT878_ARISC_START); if(bt878_debug) { for(pc2=bt->riscprog;pc2riscprog)),*pc2); } bt->nbuffers=nbufs; return 0; fail2: if(bt->riscprog) {rvfree(bt->riscprog,PAGE_SIZE); bt->riscprog=0;} fail1: if(bt->buffer) {rvfree(bt->buffer,bt->allocbufsize); bt->buffer=0; bt->allocbufsize=0;} return -ENOMEM; } EXPORT_SYMBOL(bt878_get_buffers); /*****************************/ /* Start/Stop grabbing funcs */ /*****************************/ void bt878_start(struct bt878 *bt, u32 controlreg) { if(!bt->buffer||!bt->riscprog) bt878_get_buffers(bt,0x400,1,4,0); /* this call to bt878_get_buffers ought to succeed... */ dprintk("bt878 debug: bt878_start (ctl=%8.8x)\n",controlreg); controlreg&=~0x1f; controlreg|=0x1b; btwrite(cpu_to_le32(kvirt_to_bus((unsigned long)bt->riscprog)), BT878_ARISC_START); if(bt->tasklet) tasklet_enable(bt->tasklet); btwrite(0x000ff800,BT878_AINT_MASK); btwrite(controlreg,BT878_AGPIO_DMA_CTL); } void bt878_stop(struct bt878 *bt) { u32 stat; int i=0; btwrite(0,BT878_AINT_MASK); btand(~0x1f,BT878_AGPIO_DMA_CTL); dprintk("bt878 debug: bt878_stop\n"); do { stat=btread(BT878_AINT_STAT); if(!(stat&BT878_ARISC_EN)) break; i++; } while(i<500); if(bt->tasklet) tasklet_disable(bt->tasklet); dprintk("bt878(%d) debug: bt878_stop, i=%d, stat=0x%8.8x\n",bt->nr,i,stat); } EXPORT_SYMBOL(bt878_start); EXPORT_SYMBOL(bt878_stop); /*****************************/ /* Interrupt service routine */ /*****************************/ static void bt878_irq(int irq, void *dev_id, struct pt_regs * regs) { u32 stat,astat,mask; int count; struct bt878 *bt; bt=(struct bt878 *)dev_id; count=0; while(1) { stat=btread(BT878_AINT_STAT); mask=btread(BT878_AINT_MASK); if(!(astat=(stat&mask))) return; /* this interrupt is not for me */ /* dprintk("bt878(%d) debug: irq count %d, stat 0x%8.8x, mask 0x%8.8x\n",bt->nr,count,stat,mask); */ btwrite(astat,BT878_AINT_STAT); /* try to clear interupt condition */ if(astat&(BT878_ASCERR|BT878_AOCERR)) { if(bt878_verbose) { printk("bt878(%d): irq%s%s risc_pc=%08x\n", bt->nr, (astat&BT878_ASCERR)?" SCERR":"", (astat&BT878_AOCERR)?" OCERR":"", btread(BT878_ARISC_PC)); } } if(astat&(BT878_APABORT|BT878_ARIPERR|BT878_APPERR)) { if(bt878_verbose) { printk("bt878(%d): irq%s%s%s risc_pc=%08x\n", bt->nr, (astat&BT878_APABORT)?" PABORT":"", (astat&BT878_ARIPERR)?" RIPERR":"", (astat&BT878_APPERR)?" PPERR":"", btread(BT878_ARISC_PC)); } } if(astat&(BT878_AFDSR|BT878_AFTRGT|BT878_AFBUS)) { if(bt878_verbose) { printk("bt878(%d): irq%s%s%s risc_pc=%08x\n", bt->nr, (astat&BT878_AFDSR)?" FDSR":"", (astat&BT878_AFTRGT)?" FTRGT":"", (astat&BT878_AFBUS)?" FBUS":"", btread(BT878_ARISC_PC)); } } if(astat&BT878_ARISCI) { spin_lock(&bt->s_lock); bt->writebuf=(stat&BT878_ARISCS)>>28; spin_unlock(&bt->s_lock); wake_up_interruptible(&bt->readq); if(bt->tasklet) tasklet_schedule(bt->tasklet); return; } count++; if(count>20) { btwrite(0,BT878_AINT_MASK); printk(KERN_ERR "bt878(%d): IRQ lockup, cleared int mask\n", bt->nr); break; } } } /***********************/ /* PCI device handling */ /***********************/ static int __devinit bt878_probe(struct pci_dev *dev, const struct pci_device_id *pci_id) { int result; unsigned char lat; struct bt878 *bt; #if defined(__powerpc__) unsigned int cmd; #endif printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n", bt878_num); bt=&bt878[bt878_num]; bt->dev=dev; bt->nr = bt878_num; init_waitqueue_head(&bt->readq); bt->s_lock = SPIN_LOCK_UNLOCKED; bt->shutdown=0; bt->id=dev->device; bt->irq=dev->irq; bt->bt878_adr=pci_resource_start(dev,0); if (pci_enable_device(dev)) return -EIO; if (!request_mem_region(pci_resource_start(dev,0), pci_resource_len(dev,0), "bt878")) { return -EBUSY; } pci_read_config_byte(dev, PCI_CLASS_REVISION, &bt->revision); pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ", bt878_num,bt->id, bt->revision, dev->bus->number, PCI_SLOT(dev->devfn),PCI_FUNC(dev->devfn)); printk("irq: %d, latency: %d, memory: 0x%lx\n", bt->irq, lat, bt->bt878_adr); #if defined(__powerpc__) /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */ /* response on cards with no firmware is not enabled by OF */ pci_read_config_dword(dev, PCI_COMMAND, &cmd); cmd = (cmd | PCI_COMMAND_MEMORY ); pci_write_config_dword(dev, PCI_COMMAND, cmd); #endif #ifdef __sparc__ bt->bt878_mem=(unsigned char *)bt->bt878_adr; #else bt->bt878_mem=ioremap(bt->bt878_adr, 0x1000); #endif /* clear interrupt mask */ btwrite(0, BT848_INT_MASK); result = request_irq(bt->irq, bt878_irq, SA_SHIRQ | SA_INTERRUPT,"bt878",(void *)bt); if (result==-EINVAL) { printk(KERN_ERR "bt878(%d): Bad irq number or handler\n", bt878_num); goto fail1; } if (result==-EBUSY) { printk(KERN_ERR "bt878(%d): IRQ %d busy, change your PnP config in BIOS\n",bt878_num,bt->irq); goto fail1; } if (result < 0) goto fail1; pci_set_master(dev); pci_set_drvdata(dev,bt); /* if(init_bt878(btv) < 0) { bt878_remove(dev); return -EIO; } */ bt->nbuffers=bt->allocbufsize=0; bt->buffer=bt->riscprog=0; btwrite(0,BT878_AINT_MASK); bt878_num++; return 0; /* fail2: free_irq(bt->irq,bt); */ fail1: release_mem_region(pci_resource_start(bt->dev,0), pci_resource_len(bt->dev,0)); return result; } static void __devexit bt878_remove(struct pci_dev *pci_dev) { u8 command; struct bt878 *bt = pci_get_drvdata(pci_dev); if (bt878_verbose) printk("bt878(%d): unloading\n",bt->nr); /* turn off all capturing, DMA and IRQs */ btand(~15, BT878_AGPIO_DMA_CTL); /* first disable interrupts before unmapping the memory! */ btwrite(0, BT878_AINT_MASK); btwrite(~0x0UL,BT878_AINT_STAT); /* disable PCI bus-mastering */ pci_read_config_byte(bt->dev, PCI_COMMAND, &command); /* Should this be &=~ ?? */ command&=~PCI_COMMAND_MASTER; pci_write_config_byte(bt->dev, PCI_COMMAND, command); free_irq(bt->irq,bt); printk(KERN_DEBUG "bt878_mem: 0x%p.\n", bt->bt878_mem); if (bt->bt878_mem) iounmap(bt->bt878_mem); release_mem_region(pci_resource_start(bt->dev,0), pci_resource_len(bt->dev,0)); /* wake up any waiting processes because shutdown flag is set, no new processes (in this queue) are expected */ bt->shutdown=1; if(bt->buffer) {rvfree(bt->buffer,bt->allocbufsize); bt->buffer=0;} if(bt->riscprog) {rvfree(bt->riscprog,PAGE_SIZE); bt->riscprog=0;} pci_set_drvdata(pci_dev, NULL); return; } static struct pci_device_id bt878_pci_tbl[] __devinitdata = { {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BROOKTREE_878, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {0,} }; MODULE_DEVICE_TABLE(pci, bt878_pci_tbl); static struct pci_driver bt878_pci_driver = { name: "bt878", id_table: bt878_pci_tbl, probe: bt878_probe, remove: bt878_remove, }; /*******************************/ /* Module management functions */ /*******************************/ int bt878_init_module(void) { bt878_num = 0; printk(KERN_INFO "bt878: AUDIO driver version %d.%d.%d loaded\n", (BT878_VERSION_CODE >> 16) & 0xff, (BT878_VERSION_CODE >> 8) & 0xff, BT878_VERSION_CODE & 0xff); /* bt878_check_chipset(); */ return pci_module_init(&bt878_pci_driver); } void bt878_cleanup_module(void) { pci_unregister_driver(&bt878_pci_driver); return; } module_init(bt878_init_module); module_exit(bt878_cleanup_module); /* * Local variables: * c-basic-offset: 8 * End: */