1 /* $FreeBSD: src/sys/dev/bktr/bktr_os.c,v 1.4.2.3 2000/10/27 00:46:09 jhb Exp $ */
4 * This is part of the Driver for Video Capture Cards (Frame grabbers)
5 * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
7 * Copyright Roger Hardiman and Amancio Hasty.
9 * bktr_os : This has all the Operating System dependant code,
10 * probe/attach and open/close/ioctl/read/mmap
18 * 1. Redistributions of source code must retain the
19 * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
20 * All rights reserved.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the above copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * This product includes software developed by Amancio Hasty and
34 * 4. The name of the author may not be used to endorse or promote products
35 * derived from this software without specific prior written permission.
37 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
38 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
39 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
41 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
42 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
46 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
47 * POSSIBILITY OF SUCH DAMAGE.
53 #endif /* __FreeBSD__ */
55 #include "opt_bktr.h" /* include any kernel config options */
57 #define FIFO_RISC_DISABLED 0
58 #define ALL_INTS_DISABLED 0
66 #include <sys/param.h>
67 #include <sys/systm.h>
70 #include <sys/kernel.h>
71 #include <sys/signalvar.h>
74 #include <sys/select.h>
75 #include <sys/vnode.h>
78 #include <vm/vm_kern.h>
80 #include <vm/vm_extern.h>
82 #if (__FreeBSD_version >=400000) || (NSMBUS > 0)
83 #include <sys/bus.h> /* used by smbus and newbus */
86 #if (__FreeBSD_version >=300000)
87 #include <machine/bus_memio.h> /* used by bus space */
88 #include <machine/bus.h> /* used by bus space and newbus */
92 #if (__FreeBSD_version >=400000)
93 #include <sys/rman.h> /* used by newbus */
94 #include <machine/resource.h> /* used by newbus */
97 #if (__FreeBSD_version < 500000)
98 #include <machine/clock.h> /* for DELAY */
101 #include <pci/pcivar.h>
102 #include <pci/pcireg.h>
104 #include <sys/sysctl.h>
106 int bt848_tuner = -1;
107 int bt848_reverse_mute = -1;
108 int bt848_format = -1;
109 int bt848_slow_msp_audio = -1;
111 SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
112 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
113 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
114 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
115 SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
116 SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
118 #if (__FreeBSD__ == 2)
119 #define PCIR_REVID PCI_CLASS_REG
122 #endif /* end freebsd section */
130 #endif /* __bsdi__ */
133 /**************************/
134 /* *** OpenBSD/NetBSD *** */
135 /**************************/
136 #if defined(__NetBSD__) || defined(__OpenBSD__)
138 #include <sys/param.h>
139 #include <sys/systm.h>
140 #include <sys/conf.h>
142 #include <sys/kernel.h>
143 #include <sys/signalvar.h>
144 #include <sys/mman.h>
145 #include <sys/poll.h>
146 #include <sys/select.h>
147 #include <sys/vnode.h>
152 #include <vm/vm_kern.h>
154 #include <vm/vm_extern.h>
157 #include <sys/device.h>
158 #include <dev/pci/pcivar.h>
159 #include <dev/pci/pcireg.h>
160 #include <dev/pci/pcidevs.h>
165 #define DPR(x) (bktr_debug ? printf x : 0)
169 #endif /* __NetBSD__ || __OpenBSD__ */
173 #include <dev/ic/bt8xx.h> /* NetBSD location for .h files */
174 #include <dev/pci/bktr/bktr_reg.h>
175 #include <dev/pci/bktr/bktr_tuner.h>
176 #include <dev/pci/bktr/bktr_card.h>
177 #include <dev/pci/bktr/bktr_audio.h>
178 #include <dev/pci/bktr/bktr_core.h>
179 #include <dev/pci/bktr/bktr_os.h>
180 #else /* Traditional location for .h files */
181 #include <machine/ioctl_meteor.h>
182 #include <machine/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
183 #include <dev/bktr/bktr_reg.h>
184 #include <dev/bktr/bktr_tuner.h>
185 #include <dev/bktr/bktr_card.h>
186 #include <dev/bktr/bktr_audio.h>
187 #include <dev/bktr/bktr_core.h>
188 #include <dev/bktr/bktr_os.h>
189 #if defined(BKTR_USE_FREEBSD_SMBUS)
190 #include <dev/bktr/bktr_i2c.h>
196 /****************************/
197 /* *** FreeBSD 4.x code *** */
198 /****************************/
199 #if (__FreeBSD_version >= 400000)
201 static int bktr_probe( device_t dev );
202 static int bktr_attach( device_t dev );
203 static int bktr_detach( device_t dev );
204 static int bktr_shutdown( device_t dev );
205 static void bktr_intr(void *arg) { common_bktr_intr(arg); }
207 static device_method_t bktr_methods[] = {
208 /* Device interface */
209 DEVMETHOD(device_probe, bktr_probe),
210 DEVMETHOD(device_attach, bktr_attach),
211 DEVMETHOD(device_detach, bktr_detach),
212 DEVMETHOD(device_shutdown, bktr_shutdown),
217 static driver_t bktr_driver = {
220 sizeof(struct bktr_softc),
223 static devclass_t bktr_devclass;
225 static d_open_t bktr_open;
226 static d_close_t bktr_close;
227 static d_read_t bktr_read;
228 static d_write_t bktr_write;
229 static d_ioctl_t bktr_ioctl;
230 static d_mmap_t bktr_mmap;
231 static d_poll_t bktr_poll;
233 #define CDEV_MAJOR 92
234 static struct cdevsw bktr_cdevsw = {
235 /* open */ bktr_open,
236 /* close */ bktr_close,
237 /* read */ bktr_read,
238 /* write */ bktr_write,
239 /* ioctl */ bktr_ioctl,
240 /* poll */ bktr_poll,
241 /* mmap */ bktr_mmap,
242 /* strategy */ nostrategy,
244 /* maj */ CDEV_MAJOR,
251 DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
252 #if (__FreeBSD_version > 410000)
253 MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
254 MODULE_VERSION(bktr, 1);
259 * the boot time probe routine.
262 bktr_probe( device_t dev )
264 unsigned int type = pci_get_devid(dev);
265 unsigned int rev = pci_get_revid(dev);
267 if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
269 switch (PCI_PRODUCT(type)) {
270 case PCI_PRODUCT_BROOKTREE_BT848:
272 device_set_desc(dev, "BrookTree 848A");
274 device_set_desc(dev, "BrookTree 848");
276 case PCI_PRODUCT_BROOKTREE_BT849:
277 device_set_desc(dev, "BrookTree 849A");
279 case PCI_PRODUCT_BROOKTREE_BT878:
280 device_set_desc(dev, "BrookTree 878");
282 case PCI_PRODUCT_BROOKTREE_BT879:
283 device_set_desc(dev, "BrookTree 879");
293 * the attach routine.
296 bktr_attach( device_t dev )
305 u_long old_irq, new_irq;
308 struct bktr_softc *bktr = device_get_softc(dev);
310 unit = device_get_unit(dev);
312 /* build the device name for bktr_name() */
313 snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
316 * Enable bus mastering and Memory Mapped device
318 val = pci_read_config(dev, PCIR_COMMAND, 4);
319 val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
320 pci_write_config(dev, PCIR_COMMAND, val, 4);
323 * Map control/status registers.
325 bktr->mem_rid = PCIR_MAPS;
326 bktr->res_mem = bus_alloc_resource(dev, SYS_RES_MEMORY, &bktr->mem_rid,
327 0, ~0, 1, RF_ACTIVE);
330 if (!bktr->res_mem) {
331 device_printf(dev, "could not map memory\n");
335 bktr->memt = rman_get_bustag(bktr->res_mem);
336 bktr->memh = rman_get_bushandle(bktr->res_mem);
340 * Disable the brooktree device
342 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
343 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
346 #ifdef BROOKTREE_IRQ /* from the configuration file */
347 old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
348 pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
349 new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
350 printf("bktr%d: attach: irq changed from %d to %d\n",
351 unit, (old_irq & 0xff), (new_irq & 0xff));
355 * Allocate our interrupt.
358 bktr->res_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &bktr->irq_rid,
359 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE);
360 if (bktr->res_irq == NULL) {
361 device_printf(dev, "could not map interrupt\n");
366 error = bus_setup_intr(dev, bktr->res_irq, INTR_TYPE_TTY,
367 bktr_intr, bktr, &bktr->res_ih);
369 device_printf(dev, "could not setup irq\n");
375 /* Update the Device Control Register */
376 /* on Bt878 and Bt879 cards */
377 fun = pci_read_config( dev, 0x40, 2);
378 fun = fun | 1; /* Enable writes to the sub-system vendor ID */
380 #if defined( BKTR_430_FX_MODE )
381 if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
382 fun = fun | 2; /* Enable Intel 430 FX compatibility mode */
385 #if defined( BKTR_SIS_VIA_MODE )
386 if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
387 fun = fun | 4; /* Enable SiS/VIA compatibility mode (usefull for
388 OPTi chipset motherboards too */
390 pci_write_config(dev, 0x40, fun, 2);
393 /* XXX call bt848_i2c dependent attach() routine */
394 #if defined(BKTR_USE_FREEBSD_SMBUS)
395 if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc))
396 printf("bktr%d: i2c_attach: can't attach\n", unit);
401 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if
402 * you have more than four, then 16 would probably be a better value.
404 #ifndef BROOKTREE_DEF_LATENCY_VALUE
405 #define BROOKTREE_DEF_LATENCY_VALUE 10
407 latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4);
408 latency = (latency >> 8) & 0xff;
411 printf("brooktree%d: PCI bus latency is", unit);
413 printf("brooktree%d: PCI bus latency was 0 changing to",
417 latency = BROOKTREE_DEF_LATENCY_VALUE;
418 pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4);
421 printf(" %d.\n", (int) latency);
424 /* read the pci device id and revision id */
425 fun = pci_get_devid(dev);
426 rev = pci_get_revid(dev);
428 /* call the common attach code */
429 common_bktr_attach( bktr, unit, fun, rev );
431 /* make the device entries */
432 bktr->bktrdev = make_dev(&bktr_cdevsw, unit,
433 0, 0, 0444, "bktr%d", unit);
434 bktr->tunerdev= make_dev(&bktr_cdevsw, unit+16,
435 0, 0, 0444, "tuner%d", unit);
436 bktr->vbidev = make_dev(&bktr_cdevsw, unit+32,
437 0, 0, 0444, "vbi%d" , unit);
440 /* if this is unit 0 (/dev/bktr0, /dev/tuner0, /dev/vbi0) then make */
441 /* alias entries to /dev/bktr /dev/tuner and /dev/vbi */
442 #if (__FreeBSD_version >=500000)
444 bktr->bktrdev_alias = make_dev_alias(bktr->bktrdev, "bktr");
445 bktr->tunerdev_alias= make_dev_alias(bktr->tunerdev, "tuner");
446 bktr->vbidev_alias = make_dev_alias(bktr->vbidev, "vbi");
454 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
456 bus_release_resource(dev, SYS_RES_IRQ, bktr->mem_rid, bktr->res_mem);
462 * the detach routine.
465 bktr_detach( device_t dev )
469 struct bktr_softc *bktr = device_get_softc(dev);
471 unit = device_get_unit(dev);
473 /* Disable the brooktree device */
474 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
475 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
477 /* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */
478 /* The memory is retained by the bktr_mem module so we can unload and */
479 /* then reload the main bktr driver module */
481 /* Unregister the /dev/bktrN, tunerN and vbiN devices */
482 destroy_dev(bktr->vbidev);
483 destroy_dev(bktr->tunerdev);
484 destroy_dev(bktr->bktrdev);
486 /* If this is unit 0, then destroy the alias entries too */
487 #if (__FreeBSD_version >=500000)
489 destroy_dev(bktr->vbidev_alias);
490 destroy_dev(bktr->tunerdev_alias);
491 destroy_dev(bktr->bktrdev_alias);
496 * Deallocate resources.
498 bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih);
499 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
500 bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
506 * the shutdown routine.
509 bktr_shutdown( device_t dev )
511 struct bktr_softc *bktr = device_get_softc(dev);
513 /* Disable the brooktree device */
514 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
515 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
522 * Special Memory Allocation
525 get_bktr_mem( int unit, unsigned size )
527 vm_offset_t addr = 0;
529 addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24);
531 addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE);
533 printf("bktr%d: Unable to allocate %d bytes of memory.\n",
541 /*---------------------------------------------------------
543 ** BrookTree 848 character device driver routines
545 **---------------------------------------------------------
548 #define VIDEO_DEV 0x00
549 #define TUNER_DEV 0x01
552 #define UNIT(x) ((x) & 0x0f)
553 #define FUNCTION(x) (x >> 4)
559 bktr_open( dev_t dev, int flags, int fmt, struct proc *p )
565 unit = UNIT( minor(dev) );
567 /* Get the device data */
568 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
570 /* the device is no longer valid/functioning */
574 if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
577 /* Record that the device is now busy */
578 device_busy(devclass_get_device(bktr_devclass, unit));
581 if (bt848_card != -1) {
582 if ((bt848_card >> 8 == unit ) &&
583 ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
584 if ( bktr->bt848_card != (bt848_card & 0xff) ) {
585 bktr->bt848_card = (bt848_card & 0xff);
586 probeCard(bktr, FALSE, unit);
591 if (bt848_tuner != -1) {
592 if ((bt848_tuner >> 8 == unit ) &&
593 ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
594 if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
595 bktr->bt848_tuner = (bt848_tuner & 0xff);
596 probeCard(bktr, FALSE, unit);
601 if (bt848_reverse_mute != -1) {
602 if ((bt848_reverse_mute >> 8) == unit ) {
603 bktr->reverse_mute = bt848_reverse_mute & 0xff;
607 if (bt848_slow_msp_audio != -1) {
608 if ((bt848_slow_msp_audio >> 8) == unit ) {
609 bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
613 switch ( FUNCTION( minor(dev) ) ) {
615 result = video_open( bktr );
618 result = tuner_open( bktr );
621 result = vbi_open( bktr );
628 /* If there was an error opening the device, undo the busy status */
630 device_unbusy(devclass_get_device(bktr_devclass, unit));
639 bktr_close( dev_t dev, int flags, int fmt, struct proc *p )
645 unit = UNIT( minor(dev) );
647 /* Get the device data */
648 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
650 /* the device is no longer valid/functioning */
654 switch ( FUNCTION( minor(dev) ) ) {
656 result = video_close( bktr );
659 result = tuner_close( bktr );
662 result = vbi_close( bktr );
669 device_unbusy(devclass_get_device(bktr_devclass, unit));
678 bktr_read( dev_t dev, struct uio *uio, int ioflag )
683 unit = UNIT(minor(dev));
685 /* Get the device data */
686 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
688 /* the device is no longer valid/functioning */
692 switch ( FUNCTION( minor(dev) ) ) {
694 return( video_read( bktr, unit, dev, uio ) );
696 return( vbi_read( bktr, uio, ioflag ) );
706 bktr_write( dev_t dev, struct uio *uio, int ioflag )
708 return( EINVAL ); /* XXX or ENXIO ? */
716 bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr )
721 unit = UNIT(minor(dev));
723 /* Get the device data */
724 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
726 /* the device is no longer valid/functioning */
730 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
733 switch ( FUNCTION( minor(dev) ) ) {
735 return( video_ioctl( bktr, unit, cmd, arg, pr ) );
737 return( tuner_ioctl( bktr, unit, cmd, arg, pr ) );
748 bktr_mmap( dev_t dev, vm_offset_t offset, int nprot )
753 unit = UNIT(minor(dev));
755 if (FUNCTION(minor(dev)) > 0) /* only allow mmap on /dev/bktr[n] */
758 /* Get the device data */
759 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
761 /* the device is no longer valid/functioning */
765 if (nprot & PROT_EXEC)
771 if (offset >= bktr->alloc_pages * PAGE_SIZE)
774 return( atop(vtophys(bktr->bigbuf) + offset) );
777 int bktr_poll( dev_t dev, int events, struct proc *p)
782 DECLARE_INTR_MASK(s);
784 unit = UNIT(minor(dev));
786 /* Get the device data */
787 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
789 /* the device is no longer valid/functioning */
795 if (events & (POLLIN | POLLRDNORM)) {
797 switch ( FUNCTION( minor(dev) ) ) {
799 if(bktr->vbisize == 0)
800 selrecord(p, &bktr->vbi_select);
802 revents |= events & (POLLIN | POLLRDNORM);
812 #endif /* FreeBSD 4.x specific kernel interface routines */
814 /**********************************/
815 /* *** FreeBSD 2.2.x and 3.x *** */
816 /**********************************/
818 #if ((__FreeBSD__ == 2) || (__FreeBSD__ == 3))
820 static bktr_reg_t brooktree[ NBKTR ];
822 static const char* bktr_probe( pcici_t tag, pcidi_t type );
823 static void bktr_attach( pcici_t tag, int unit );
824 static void bktr_intr(void *arg) { common_bktr_intr(arg); }
826 static u_long bktr_count;
828 static struct pci_device bktr_device = {
835 DATA_SET (pcidevice_set, bktr_device);
837 static d_open_t bktr_open;
838 static d_close_t bktr_close;
839 static d_read_t bktr_read;
840 static d_write_t bktr_write;
841 static d_ioctl_t bktr_ioctl;
842 static d_mmap_t bktr_mmap;
843 static d_poll_t bktr_poll;
845 #define CDEV_MAJOR 92
846 static struct cdevsw bktr_cdevsw =
848 bktr_open, bktr_close, bktr_read, bktr_write,
849 bktr_ioctl, nostop, nullreset, nodevtotty,
850 bktr_poll, bktr_mmap, NULL, "bktr",
854 static int bktr_devsw_installed;
857 bktr_drvinit( void *unused )
861 if ( ! bktr_devsw_installed ) {
862 dev = makedev(CDEV_MAJOR, 0);
863 cdevsw_add(&dev,&bktr_cdevsw, NULL);
864 bktr_devsw_installed = 1;
868 SYSINIT(bktrdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bktr_drvinit,NULL)
871 * the boot time probe routine.
874 bktr_probe( pcici_t tag, pcidi_t type )
876 unsigned int rev = pci_conf_read( tag, PCIR_REVID) & 0x000000ff;
878 if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
880 switch (PCI_PRODUCT(type)) {
881 case PCI_PRODUCT_BROOKTREE_BT848:
882 if (rev == 0x12) return("BrookTree 848A");
883 else return("BrookTree 848");
884 case PCI_PRODUCT_BROOKTREE_BT849:
885 return("BrookTree 849A");
886 case PCI_PRODUCT_BROOKTREE_BT878:
887 return("BrookTree 878");
888 case PCI_PRODUCT_BROOKTREE_BT879:
889 return("BrookTree 879");
897 * the attach routine.
900 bktr_attach( pcici_t tag, int unit )
908 u_long old_irq, new_irq;
911 bktr = &brooktree[unit];
914 printf("brooktree%d: attach: only %d units configured.\n",
916 printf("brooktree%d: attach: invalid unit number.\n", unit);
920 /* build the device name for bktr_name() */
921 snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
923 /* Enable Memory Mapping */
924 fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG);
925 pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 2);
927 /* Enable Bus Mastering */
928 fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG);
929 pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 4);
935 * Map control/status registers
937 pci_map_mem( tag, PCI_MAP_REG_START, (vm_offset_t *) &base,
939 #if (__FreeBSD_version >= 300000)
940 bktr->memt = I386_BUS_SPACE_MEM; /* XXX should use proper bus space */
941 bktr->memh = (bus_space_handle_t)base; /* XXX functions here */
945 * Disable the brooktree device
947 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
948 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
950 #ifdef BROOKTREE_IRQ /* from the configuration file */
951 old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
952 pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
953 new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
954 printf("bktr%d: attach: irq changed from %d to %d\n",
955 unit, (old_irq & 0xff), (new_irq & 0xff));
959 * setup the interrupt handling routine
961 pci_map_int(tag, bktr_intr, (void*) bktr, &tty_imask);
964 /* Update the Device Control Register */
965 /* on Bt878 and Bt879 cards */
966 fun = pci_conf_read(tag, 0x40);
967 fun = fun | 1; /* Enable writes to the sub-system vendor ID */
969 #if defined( BKTR_430_FX_MODE )
970 if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
971 fun = fun | 2; /* Enable Intel 430 FX compatibility mode */
974 #if defined( BKTR_SIS_VIA_MODE )
975 if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
976 fun = fun | 4; /* Enable SiS/VIA compatibility mode (usefull for
977 OPTi chipset motherboards too */
979 pci_conf_write(tag, 0x40, fun);
982 /* XXX call bt848_i2c dependent attach() routine */
983 #if defined(BKTR_USE_FREEBSD_SMBUS)
984 if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc))
985 printf("bktr%d: i2c_attach: can't attach\n", unit);
990 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if
991 * you have more than four, then 16 would probably be a better value.
993 #ifndef BROOKTREE_DEF_LATENCY_VALUE
994 #define BROOKTREE_DEF_LATENCY_VALUE 10
996 latency = pci_conf_read(tag, PCI_LATENCY_TIMER);
997 latency = (latency >> 8) & 0xff;
1000 printf("brooktree%d: PCI bus latency is", unit);
1002 printf("brooktree%d: PCI bus latency was 0 changing to",
1006 latency = BROOKTREE_DEF_LATENCY_VALUE;
1007 pci_conf_write(tag, PCI_LATENCY_TIMER, latency<<8);
1009 if ( bootverbose ) {
1010 printf(" %d.\n", (int) latency);
1014 /* read the pci device id and revision id */
1015 fun = pci_conf_read(tag, PCI_ID_REG);
1016 rev = pci_conf_read(tag, PCIR_REVID) & 0x000000ff;
1018 /* call the common attach code */
1019 common_bktr_attach( bktr, unit, fun, rev );
1025 * Special Memory Allocation
1028 get_bktr_mem( int unit, unsigned size )
1030 vm_offset_t addr = 0;
1032 addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, 1<<24);
1034 addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff,
1037 printf("bktr%d: Unable to allocate %d bytes of memory.\n",
1044 /*---------------------------------------------------------
1046 ** BrookTree 848 character device driver routines
1048 **---------------------------------------------------------
1052 #define VIDEO_DEV 0x00
1053 #define TUNER_DEV 0x01
1054 #define VBI_DEV 0x02
1056 #define UNIT(x) ((x) & 0x0f)
1057 #define FUNCTION(x) ((x >> 4) & 0x0f)
1064 bktr_open( dev_t dev, int flags, int fmt, struct proc *p )
1069 unit = UNIT( minor(dev) );
1070 if (unit >= NBKTR) /* unit out of range */
1073 bktr = &(brooktree[ unit ]);
1075 if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
1079 if (bt848_card != -1) {
1080 if ((bt848_card >> 8 == unit ) &&
1081 ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
1082 if ( bktr->bt848_card != (bt848_card & 0xff) ) {
1083 bktr->bt848_card = (bt848_card & 0xff);
1084 probeCard(bktr, FALSE, unit);
1089 if (bt848_tuner != -1) {
1090 if ((bt848_tuner >> 8 == unit ) &&
1091 ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
1092 if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
1093 bktr->bt848_tuner = (bt848_tuner & 0xff);
1094 probeCard(bktr, FALSE, unit);
1099 if (bt848_reverse_mute != -1) {
1100 if ((bt848_reverse_mute >> 8) == unit ) {
1101 bktr->reverse_mute = bt848_reverse_mute & 0xff;
1105 if (bt848_slow_msp_audio != -1) {
1106 if ((bt848_slow_msp_audio >> 8) == unit ) {
1107 bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
1111 switch ( FUNCTION( minor(dev) ) ) {
1113 return( video_open( bktr ) );
1115 return( tuner_open( bktr ) );
1117 return( vbi_open( bktr ) );
1127 bktr_close( dev_t dev, int flags, int fmt, struct proc *p )
1132 unit = UNIT( minor(dev) );
1133 if (unit >= NBKTR) /* unit out of range */
1136 bktr = &(brooktree[ unit ]);
1138 switch ( FUNCTION( minor(dev) ) ) {
1140 return( video_close( bktr ) );
1142 return( tuner_close( bktr ) );
1144 return( vbi_close( bktr ) );
1154 bktr_read( dev_t dev, struct uio *uio, int ioflag )
1159 unit = UNIT(minor(dev));
1160 if (unit >= NBKTR) /* unit out of range */
1163 bktr = &(brooktree[unit]);
1165 switch ( FUNCTION( minor(dev) ) ) {
1167 return( video_read( bktr, unit, dev, uio ) );
1169 return( vbi_read( bktr, uio, ioflag ) );
1179 bktr_write( dev_t dev, struct uio *uio, int ioflag )
1181 return( EINVAL ); /* XXX or ENXIO ? */
1188 bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr )
1193 unit = UNIT(minor(dev));
1194 if (unit >= NBKTR) /* unit out of range */
1197 bktr = &(brooktree[ unit ]);
1199 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
1202 switch ( FUNCTION( minor(dev) ) ) {
1204 return( video_ioctl( bktr, unit, cmd, arg, pr ) );
1206 return( tuner_ioctl( bktr, unit, cmd, arg, pr ) );
1214 * Note: 2.2.5/2.2.6/2.2.7/3.0 users must manually
1215 * edit the line below and change "vm_offset_t" to "int"
1217 int bktr_mmap( dev_t dev, vm_offset_t offset, int nprot )
1223 unit = UNIT(minor(dev));
1225 if (unit >= NBKTR || FUNCTION(minor(dev)) > 0)
1228 bktr = &(brooktree[ unit ]);
1230 if (nprot & PROT_EXEC)
1236 if (offset >= bktr->alloc_pages * PAGE_SIZE)
1239 return( i386_btop(vtophys(bktr->bigbuf) + offset) );
1242 int bktr_poll( dev_t dev, int events, struct proc *p)
1248 unit = UNIT(minor(dev));
1253 bktr = &(brooktree[ unit ]);
1257 if (events & (POLLIN | POLLRDNORM)) {
1259 switch ( FUNCTION( minor(dev) ) ) {
1261 if(bktr->vbisize == 0)
1262 selrecord(p, &bktr->vbi_select);
1264 revents |= events & (POLLIN | POLLRDNORM);
1275 #endif /* FreeBSD 2.2.x and 3.x specific kernel interface routines */
1282 #if defined(__bsdi__)
1283 #endif /* __bsdi__ BSDI specific kernel interface routines */
1286 /*****************************/
1287 /* *** OpenBSD / NetBSD *** */
1288 /*****************************/
1289 #if defined(__NetBSD__) || defined(__OpenBSD__)
1291 #define IPL_VIDEO IPL_BIO /* XXX */
1293 static int bktr_intr(void *arg) { return common_bktr_intr(arg); }
1295 #define bktr_open bktropen
1296 #define bktr_close bktrclose
1297 #define bktr_read bktrread
1298 #define bktr_write bktrwrite
1299 #define bktr_ioctl bktrioctl
1300 #define bktr_mmap bktrmmap
1302 vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
1303 vm_offset_t, vm_offset_t);
1305 #if defined(__OpenBSD__)
1306 static int bktr_probe __P((struct device *, void *, void *));
1308 static int bktr_probe __P((struct device *, struct cfdata *, void *));
1310 static void bktr_attach __P((struct device *, struct device *, void *));
1312 struct cfattach bktr_ca = {
1313 sizeof(struct bktr_softc), bktr_probe, bktr_attach
1316 #if defined(__NetBSD__)
1317 extern struct cfdriver bktr_cd;
1319 struct cfdriver bktr_cd = {
1320 NULL, "bktr", DV_DULL
1325 bktr_probe(parent, match, aux)
1326 struct device *parent;
1327 #if defined(__OpenBSD__)
1330 struct cfdata *match;
1334 struct pci_attach_args *pa = aux;
1336 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE &&
1337 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 ||
1338 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 ||
1339 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 ||
1340 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879))
1348 * the attach routine.
1351 bktr_attach(struct device *parent, struct device *self, void *aux)
1358 #if defined(__OpenBSD__)
1359 struct pci_attach_args *pa = aux;
1360 pci_chipset_tag_t pc = pa->pa_pc;
1362 pci_intr_handle_t ih;
1363 const char *intrstr;
1367 bktr = (bktr_ptr_t)self;
1368 unit = bktr->bktr_dev.dv_unit;
1370 bktr->pc = pa->pa_pc;
1371 bktr->tag = pa->pa_tag;
1372 bktr->dmat = pa->pa_dmat;
1377 bktr->memt = pa->pa_memt;
1378 retval = pci_mem_find(pc, pa->pa_tag, PCI_MAPREG_START,
1379 &bktr->phys_base, &bktr->obmemsz, NULL);
1381 retval = bus_space_map(pa->pa_memt, bktr->phys_base,
1382 bktr->obmemsz, 0, &bktr->memh);
1384 printf(": couldn't map memory\n");
1392 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
1393 pa->pa_intrline, &ih)) {
1394 printf(": couldn't map interrupt\n");
1397 intrstr = pci_intr_string(pa->pa_pc, ih);
1399 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
1400 bktr_intr, bktr, bktr->bktr_dev.dv_xname);
1401 if (bktr->ih == NULL) {
1402 printf(": couldn't establish interrupt");
1403 if (intrstr != NULL)
1404 printf(" at %s", intrstr);
1409 if (intrstr != NULL)
1410 printf(": %s\n", intrstr);
1411 #endif /* __OpenBSD__ */
1413 #if defined(__NetBSD__)
1414 struct pci_attach_args *pa = aux;
1415 pci_intr_handle_t ih;
1416 const char *intrstr;
1420 bktr = (bktr_ptr_t)self;
1421 unit = bktr->bktr_dev.dv_unit;
1422 bktr->dmat = pa->pa_dmat;
1429 retval = pci_mapreg_map(pa, PCI_MAPREG_START,
1431 | PCI_MAPREG_MEM_TYPE_32BIT, 0,
1432 &bktr->memt, &bktr->memh, NULL,
1434 DPR(("pci_mapreg_map: memt %x, memh %x, size %x\n",
1435 bktr->memt, (u_int)bktr->memh, (u_int)bktr->obmemsz));
1437 printf("%s: couldn't map memory\n", bktr_name(bktr));
1442 * Disable the brooktree device
1444 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1445 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1450 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
1451 pa->pa_intrline, &ih)) {
1452 printf("%s: couldn't map interrupt\n",
1456 intrstr = pci_intr_string(pa->pa_pc, ih);
1457 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
1459 if (bktr->ih == NULL) {
1460 printf("%s: couldn't establish interrupt",
1462 if (intrstr != NULL)
1463 printf(" at %s", intrstr);
1467 if (intrstr != NULL)
1468 printf("%s: interrupting at %s\n", bktr_name(bktr),
1470 #endif /* __NetBSD__ */
1473 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if
1474 * you have more than four, then 16 would probably be a better value.
1476 #ifndef BROOKTREE_DEF_LATENCY_VALUE
1477 #define BROOKTREE_DEF_LATENCY_VALUE 10
1479 latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER);
1480 latency = (latency >> 8) & 0xff;
1484 printf("%s: PCI bus latency was 0 changing to %d",
1485 bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE);
1487 latency = BROOKTREE_DEF_LATENCY_VALUE;
1488 pci_conf_write(pa->pa_pc, pa->pa_tag,
1489 PCI_LATENCY_TIMER, latency<<8);
1493 /* Enabled Bus Master
1494 XXX: check if all old DMA is stopped first (e.g. after warm
1496 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
1497 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
1498 fun | PCI_COMMAND_MASTER_ENABLE);
1500 /* read the pci id and determine the card type */
1501 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
1502 rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff;
1504 common_bktr_attach(bktr, unit, fun, rev);
1509 * Special Memory Allocation
1512 get_bktr_mem(bktr, dmapp, size)
1514 bus_dmamap_t *dmapp;
1517 bus_dma_tag_t dmat = bktr->dmat;
1518 bus_dma_segment_t seg;
1524 * Allocate a DMA area
1527 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1528 &rseg, BUS_DMA_NOWAIT)) {
1530 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1531 &rseg, BUS_DMA_NOWAIT)) {
1532 printf("%s: Unable to dmamem_alloc of %d bytes\n",
1533 bktr_name(bktr), size);
1537 if (bus_dmamem_map(dmat, &seg, rseg, size,
1538 &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
1539 printf("%s: Unable to dmamem_map of %d bytes\n",
1540 bktr_name(bktr), size);
1541 bus_dmamem_free(dmat, &seg, rseg);
1545 bktr->dm_mapsize = size;
1548 * Create and locd the DMA map for the DMA area
1550 if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) {
1551 printf("%s: Unable to dmamap_create of %d bytes\n",
1552 bktr_name(bktr), size);
1553 bus_dmamem_unmap(dmat, kva, size);
1554 bus_dmamem_free(dmat, &seg, rseg);
1557 if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) {
1558 printf("%s: Unable to dmamap_load of %d bytes\n",
1559 bktr_name(bktr), size);
1560 bus_dmamem_unmap(dmat, kva, size);
1561 bus_dmamem_free(dmat, &seg, rseg);
1562 bus_dmamap_destroy(dmat, *dmapp);
1565 return (vm_offset_t)kva;
1569 free_bktr_mem(bktr, dmap, kva)
1574 bus_dma_tag_t dmat = bktr->dmat;
1577 bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize);
1579 bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize);
1581 bus_dmamem_free(dmat, dmap->dm_segs, 1);
1582 bus_dmamap_destroy(dmat, dmap);
1586 /*---------------------------------------------------------
1588 ** BrookTree 848 character device driver routines
1590 **---------------------------------------------------------
1594 #define VIDEO_DEV 0x00
1595 #define TUNER_DEV 0x01
1596 #define VBI_DEV 0x02
1598 #define UNIT(x) (minor((x) & 0x0f))
1599 #define FUNCTION(x) (minor((x >> 4) & 0x0f))
1605 bktr_open(dev_t dev, int flags, int fmt, struct proc *p)
1612 /* unit out of range */
1613 if ((unit > bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL))
1616 bktr = bktr_cd.cd_devs[unit];
1618 if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
1621 switch (FUNCTION(dev)) {
1623 return(video_open(bktr));
1625 return(tuner_open(bktr));
1627 return(vbi_open(bktr));
1638 bktr_close(dev_t dev, int flags, int fmt, struct proc *p)
1645 bktr = bktr_cd.cd_devs[unit];
1647 switch (FUNCTION(dev)) {
1649 return(video_close(bktr));
1651 return(tuner_close(bktr));
1653 return(vbi_close(bktr));
1663 bktr_read(dev_t dev, struct uio *uio, int ioflag)
1670 bktr = bktr_cd.cd_devs[unit];
1672 switch (FUNCTION(dev)) {
1674 return(video_read(bktr, unit, dev, uio));
1676 return(vbi_read(bktr, uio, ioflag));
1687 bktr_write(dev_t dev, struct uio *uio, int ioflag)
1689 /* operation not supported */
1697 bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr)
1704 bktr = bktr_cd.cd_devs[unit];
1706 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
1709 switch (FUNCTION(dev)) {
1711 return(video_ioctl(bktr, unit, cmd, arg, pr));
1713 return(tuner_ioctl(bktr, unit, cmd, arg, pr));
1723 bktr_mmap(dev_t dev, off_t offset, int nprot)
1730 if (FUNCTION(dev) > 0) /* only allow mmap on /dev/bktr[n] */
1733 bktr = bktr_cd.cd_devs[unit];
1735 if ((vaddr_t)offset < 0)
1738 if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE)
1742 return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1,
1743 (vaddr_t)offset, nprot, BUS_DMA_WAITOK));
1745 return(i386_btop(vtophys(bktr->bigbuf) + offset));
1749 #endif /* __NetBSD__ || __OpenBSD__ */