bktr_os.c revision 139917
1/*-
2 * 1. Redistributions of source code must retain the
3 * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 *    must display the following acknowledgement:
16 *	This product includes software developed by Amancio Hasty and
17 *      Roger Hardiman
18 * 4. The name of the author may not be used to endorse or promote products
19 *    derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <sys/cdefs.h>
35__FBSDID("$FreeBSD: head/sys/dev/bktr/bktr_os.c 139917 2005-01-08 22:43:33Z imp $");
36
37/*
38 * This is part of the Driver for Video Capture Cards (Frame grabbers)
39 * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
40 * chipset.
41 * Copyright Roger Hardiman and Amancio Hasty.
42 *
43 * bktr_os : This has all the Operating System dependant code,
44 *             probe/attach and open/close/ioctl/read/mmap
45 *             memory allocation
46 *             PCI bus interfacing
47 */
48
49#include "opt_bktr.h"		/* include any kernel config options */
50
51#define FIFO_RISC_DISABLED      0
52#define ALL_INTS_DISABLED       0
53
54
55/*******************/
56/* *** FreeBSD *** */
57/*******************/
58#ifdef __FreeBSD__
59
60#include <sys/param.h>
61#include <sys/systm.h>
62#include <sys/conf.h>
63#include <sys/uio.h>
64#include <sys/kernel.h>
65#include <sys/module.h>
66#include <sys/signalvar.h>
67#include <sys/malloc.h>
68#include <sys/mman.h>
69#include <sys/poll.h>
70#if __FreeBSD_version >= 500014
71#include <sys/selinfo.h>
72#else
73#include <sys/select.h>
74#endif
75
76#include <vm/vm.h>
77#include <vm/vm_kern.h>
78#include <vm/pmap.h>
79#include <vm/vm_extern.h>
80
81#if (__FreeBSD_version >=400000)
82#include <sys/bus.h>		/* used by smbus and newbus */
83#endif
84
85#if (__FreeBSD_version >=300000)
86#include <machine/bus_memio.h>	/* used by bus space */
87#include <machine/bus.h>	/* used by bus space and newbus */
88#include <sys/bus.h>
89#endif
90
91#if (__FreeBSD_version >=400000)
92#include <sys/rman.h>		/* used by newbus */
93#include <machine/resource.h>	/* used by newbus */
94#endif
95
96#if (__FreeBSD_version < 500000)
97#include <machine/clock.h>              /* for DELAY */
98#include <pci/pcivar.h>
99#include <pci/pcireg.h>
100#else
101#include <dev/pci/pcivar.h>
102#include <dev/pci/pcireg.h>
103#endif
104
105#include <sys/sysctl.h>
106int bt848_card = -1;
107int bt848_tuner = -1;
108int bt848_reverse_mute = -1;
109int bt848_format = -1;
110int bt848_slow_msp_audio = -1;
111#ifdef BKTR_NEW_MSP34XX_DRIVER
112int bt848_stereo_once = 0;	/* no continuous stereo monitoring */
113int bt848_amsound = 0;		/* hard-wire AM sound at 6.5 Hz (france),
114				   the autoscan seems work well only with FM... */
115int bt848_dolby = 0;
116#endif
117
118SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
119SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
120SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
121SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
122SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
123SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
124#ifdef BKTR_NEW_MSP34XX_DRIVER
125SYSCTL_INT(_hw_bt848, OID_AUTO, stereo_once, CTLFLAG_RW, &bt848_stereo_once, 0, "");
126SYSCTL_INT(_hw_bt848, OID_AUTO, amsound, CTLFLAG_RW, &bt848_amsound, 0, "");
127SYSCTL_INT(_hw_bt848, OID_AUTO, dolby, CTLFLAG_RW, &bt848_dolby, 0, "");
128#endif
129
130#endif /* end freebsd section */
131
132
133
134/****************/
135/* *** BSDI *** */
136/****************/
137#ifdef __bsdi__
138#endif /* __bsdi__ */
139
140
141/**************************/
142/* *** OpenBSD/NetBSD *** */
143/**************************/
144#if defined(__NetBSD__) || defined(__OpenBSD__)
145
146#include <sys/param.h>
147#include <sys/systm.h>
148#include <sys/conf.h>
149#include <sys/uio.h>
150#include <sys/kernel.h>
151#include <sys/signalvar.h>
152#include <sys/mman.h>
153#include <sys/poll.h>
154#include <sys/select.h>
155#include <sys/vnode.h>
156
157#include <vm/vm.h>
158
159#ifndef __NetBSD__
160#include <vm/vm_kern.h>
161#include <vm/pmap.h>
162#include <vm/vm_extern.h>
163#endif
164
165#include <sys/device.h>
166#include <dev/pci/pcivar.h>
167#include <dev/pci/pcireg.h>
168#include <dev/pci/pcidevs.h>
169
170#define BKTR_DEBUG
171#ifdef BKTR_DEBUG
172int bktr_debug = 0;
173#define DPR(x)	(bktr_debug ? printf x : 0)
174#else
175#define DPR(x)
176#endif
177#endif /* __NetBSD__ || __OpenBSD__ */
178
179
180#ifdef __NetBSD__
181#include <dev/ic/bt8xx.h>	/* NetBSD location for .h files */
182#include <dev/pci/bktr/bktr_reg.h>
183#include <dev/pci/bktr/bktr_tuner.h>
184#include <dev/pci/bktr/bktr_card.h>
185#include <dev/pci/bktr/bktr_audio.h>
186#include <dev/pci/bktr/bktr_core.h>
187#include <dev/pci/bktr/bktr_os.h>
188#else					/* Traditional location for .h files */
189#include <dev/bktr/ioctl_meteor.h>
190#include <dev/bktr/ioctl_bt848.h>	/* extensions to ioctl_meteor.h */
191#include <dev/bktr/bktr_reg.h>
192#include <dev/bktr/bktr_tuner.h>
193#include <dev/bktr/bktr_card.h>
194#include <dev/bktr/bktr_audio.h>
195#include <dev/bktr/bktr_core.h>
196#include <dev/bktr/bktr_os.h>
197
198#if defined(BKTR_USE_FREEBSD_SMBUS)
199#include <dev/bktr/bktr_i2c.h>
200
201#include "iicbb_if.h"
202#include "smbus_if.h"
203#endif
204#endif
205
206
207/****************************/
208/* *** FreeBSD 4.x code *** */
209/****************************/
210#if (__FreeBSD_version >= 400000)
211
212static int	bktr_probe( device_t dev );
213static int	bktr_attach( device_t dev );
214static int	bktr_detach( device_t dev );
215static int	bktr_shutdown( device_t dev );
216static void	bktr_intr(void *arg) { common_bktr_intr(arg); }
217
218static device_method_t bktr_methods[] = {
219	/* Device interface */
220	DEVMETHOD(device_probe,         bktr_probe),
221	DEVMETHOD(device_attach,        bktr_attach),
222	DEVMETHOD(device_detach,        bktr_detach),
223	DEVMETHOD(device_shutdown,      bktr_shutdown),
224
225#if defined(BKTR_USE_FREEBSD_SMBUS)
226	/* iicbb interface */
227	DEVMETHOD(iicbb_callback,	bti2c_iic_callback),
228	DEVMETHOD(iicbb_setsda,		bti2c_iic_setsda),
229	DEVMETHOD(iicbb_setscl,		bti2c_iic_setscl),
230	DEVMETHOD(iicbb_getsda,		bti2c_iic_getsda),
231	DEVMETHOD(iicbb_getscl,		bti2c_iic_getscl),
232	DEVMETHOD(iicbb_reset,		bti2c_iic_reset),
233
234	/* smbus interface */
235	DEVMETHOD(smbus_callback,	bti2c_smb_callback),
236	DEVMETHOD(smbus_writeb,		bti2c_smb_writeb),
237	DEVMETHOD(smbus_writew,		bti2c_smb_writew),
238	DEVMETHOD(smbus_readb,		bti2c_smb_readb),
239#endif
240
241	{ 0, 0 }
242};
243
244static driver_t bktr_driver = {
245	"bktr",
246	bktr_methods,
247	sizeof(struct bktr_softc),
248};
249
250static devclass_t bktr_devclass;
251
252static	d_open_t	bktr_open;
253static	d_close_t	bktr_close;
254static	d_read_t	bktr_read;
255static	d_write_t	bktr_write;
256static	d_ioctl_t	bktr_ioctl;
257static	d_mmap_t	bktr_mmap;
258static	d_poll_t	bktr_poll;
259
260static struct cdevsw bktr_cdevsw = {
261	.d_version =	D_VERSION,
262	.d_flags =	D_NEEDGIANT,
263	.d_open =	bktr_open,
264	.d_close =	bktr_close,
265	.d_read =	bktr_read,
266	.d_write =	bktr_write,
267	.d_ioctl =	bktr_ioctl,
268	.d_poll =	bktr_poll,
269	.d_mmap =	bktr_mmap,
270	.d_name =	"bktr",
271};
272
273DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
274#if (__FreeBSD_version > 410000)
275MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
276MODULE_VERSION(bktr, 1);
277#endif
278
279
280/*
281 * the boot time probe routine.
282 */
283static int
284bktr_probe( device_t dev )
285{
286	unsigned int type = pci_get_devid(dev);
287        unsigned int rev  = pci_get_revid(dev);
288
289	if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
290	{
291		switch (PCI_PRODUCT(type)) {
292		case PCI_PRODUCT_BROOKTREE_BT848:
293			if (rev == 0x12)
294				device_set_desc(dev, "BrookTree 848A");
295			else
296				device_set_desc(dev, "BrookTree 848");
297			return 0;
298		case PCI_PRODUCT_BROOKTREE_BT849:
299			device_set_desc(dev, "BrookTree 849A");
300			return 0;
301		case PCI_PRODUCT_BROOKTREE_BT878:
302			device_set_desc(dev, "BrookTree 878");
303			return 0;
304		case PCI_PRODUCT_BROOKTREE_BT879:
305			device_set_desc(dev, "BrookTree 879");
306			return 0;
307		}
308	};
309
310        return ENXIO;
311}
312
313
314/*
315 * the attach routine.
316 */
317static int
318bktr_attach( device_t dev )
319{
320	u_long		latency;
321	u_long		fun;
322	u_long		val;
323	unsigned int	rev;
324	unsigned int	unit;
325	int		error = 0;
326#ifdef BROOKTREE_IRQ
327	u_long		old_irq, new_irq;
328#endif
329
330        struct bktr_softc *bktr = device_get_softc(dev);
331
332	unit = device_get_unit(dev);
333
334	/* build the device name for bktr_name() */
335	snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
336
337	/*
338	 * Enable bus mastering and Memory Mapped device
339	 */
340	val = pci_read_config(dev, PCIR_COMMAND, 4);
341	val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
342	pci_write_config(dev, PCIR_COMMAND, val, 4);
343
344	/*
345	 * Map control/status registers.
346	 */
347	bktr->mem_rid = PCIR_BAR(0);
348	bktr->res_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
349					&bktr->mem_rid, RF_ACTIVE);
350
351	if (!bktr->res_mem) {
352		device_printf(dev, "could not map memory\n");
353		error = ENXIO;
354		goto fail;
355	}
356	bktr->memt = rman_get_bustag(bktr->res_mem);
357	bktr->memh = rman_get_bushandle(bktr->res_mem);
358
359
360	/*
361	 * Disable the brooktree device
362	 */
363	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
364	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
365
366
367#ifdef BROOKTREE_IRQ		/* from the configuration file */
368	old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
369	pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
370	new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
371	printf("bktr%d: attach: irq changed from %d to %d\n",
372		unit, (old_irq & 0xff), (new_irq & 0xff));
373#endif
374
375	/*
376	 * Allocate our interrupt.
377	 */
378	bktr->irq_rid = 0;
379	bktr->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
380				&bktr->irq_rid, RF_SHAREABLE | RF_ACTIVE);
381	if (bktr->res_irq == NULL) {
382		device_printf(dev, "could not map interrupt\n");
383		error = ENXIO;
384		goto fail;
385	}
386
387	error = bus_setup_intr(dev, bktr->res_irq, INTR_TYPE_TTY,
388                               bktr_intr, bktr, &bktr->res_ih);
389	if (error) {
390		device_printf(dev, "could not setup irq\n");
391		goto fail;
392
393	}
394
395
396	/* Update the Device Control Register */
397	/* on Bt878 and Bt879 cards           */
398	fun = pci_read_config( dev, 0x40, 2);
399        fun = fun | 1;	/* Enable writes to the sub-system vendor ID */
400
401#if defined( BKTR_430_FX_MODE )
402	if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
403        fun = fun | 2;	/* Enable Intel 430 FX compatibility mode */
404#endif
405
406#if defined( BKTR_SIS_VIA_MODE )
407	if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
408        fun = fun | 4;	/* Enable SiS/VIA compatibility mode (usefull for
409                           OPTi chipset motherboards too */
410#endif
411	pci_write_config(dev, 0x40, fun, 2);
412
413#if defined(BKTR_USE_FREEBSD_SMBUS)
414	if (bt848_i2c_attach(dev))
415		printf("bktr%d: i2c_attach: can't attach\n", unit);
416#endif
417
418/*
419 * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
420 * you have more than four, then 16 would probably be a better value.
421 */
422#ifndef BROOKTREE_DEF_LATENCY_VALUE
423#define BROOKTREE_DEF_LATENCY_VALUE	10
424#endif
425	latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4);
426	latency = (latency >> 8) & 0xff;
427	if ( bootverbose ) {
428		if (latency)
429			printf("brooktree%d: PCI bus latency is", unit);
430		else
431			printf("brooktree%d: PCI bus latency was 0 changing to",
432				unit);
433	}
434	if ( !latency ) {
435		latency = BROOKTREE_DEF_LATENCY_VALUE;
436		pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4);
437	}
438	if ( bootverbose ) {
439		printf(" %d.\n", (int) latency);
440	}
441
442	/* read the pci device id and revision id */
443	fun = pci_get_devid(dev);
444        rev = pci_get_revid(dev);
445
446	/* call the common attach code */
447	common_bktr_attach( bktr, unit, fun, rev );
448
449	/* make the device entries */
450	bktr->bktrdev = make_dev(&bktr_cdevsw, unit,
451				0, 0, 0444, "bktr%d",  unit);
452	bktr->tunerdev= make_dev(&bktr_cdevsw, unit+16,
453				0, 0, 0444, "tuner%d", unit);
454	bktr->vbidev  = make_dev(&bktr_cdevsw, unit+32,
455				0, 0, 0444, "vbi%d"  , unit);
456
457
458	/* if this is unit 0 (/dev/bktr0, /dev/tuner0, /dev/vbi0) then make */
459	/* alias entries to /dev/bktr /dev/tuner and /dev/vbi */
460#if (__FreeBSD_version >=500000)
461	if (unit == 0) {
462		bktr->bktrdev_alias = make_dev_alias(bktr->bktrdev,  "bktr");
463		bktr->tunerdev_alias= make_dev_alias(bktr->tunerdev, "tuner");
464		bktr->vbidev_alias  = make_dev_alias(bktr->vbidev,   "vbi");
465	}
466#endif
467
468	return 0;
469
470fail:
471	if (bktr->res_irq)
472		bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
473	if (bktr->res_mem)
474		bus_release_resource(dev, SYS_RES_IRQ, bktr->mem_rid, bktr->res_mem);
475	return error;
476
477}
478
479/*
480 * the detach routine.
481 */
482static int
483bktr_detach( device_t dev )
484{
485	struct bktr_softc *bktr = device_get_softc(dev);
486
487#ifdef BKTR_NEW_MSP34XX_DRIVER
488	/* Disable the soundchip and kernel thread */
489	if (bktr->msp3400c_info != NULL)
490		msp_detach(bktr);
491#endif
492
493	/* Disable the brooktree device */
494	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
495	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
496
497#if defined(BKTR_USE_FREEBSD_SMBUS)
498	if (bt848_i2c_detach(dev))
499		printf("bktr%d: i2c_attach: can't attach\n",
500		     device_get_unit(dev));
501#endif
502#ifdef USE_VBIMUTEX
503        mtx_destroy(&bktr->vbimutex);
504#endif
505
506	/* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */
507	/* The memory is retained by the bktr_mem module so we can unload and */
508	/* then reload the main bktr driver module */
509
510	/* Unregister the /dev/bktrN, tunerN and vbiN devices,
511	 * the aliases for unit 0 are automatically destroyed */
512	destroy_dev(bktr->vbidev);
513	destroy_dev(bktr->tunerdev);
514	destroy_dev(bktr->bktrdev);
515
516	/*
517	 * Deallocate resources.
518	 */
519	bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih);
520	bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
521	bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
522
523	return 0;
524}
525
526/*
527 * the shutdown routine.
528 */
529static int
530bktr_shutdown( device_t dev )
531{
532	struct bktr_softc *bktr = device_get_softc(dev);
533
534	/* Disable the brooktree device */
535	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
536	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
537
538	return 0;
539}
540
541
542/*
543 * Special Memory Allocation
544 */
545vm_offset_t
546get_bktr_mem( int unit, unsigned size )
547{
548	vm_offset_t	addr = 0;
549
550	addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
551	    0xffffffff, 1<<24, 0);
552	if (addr == 0)
553		addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
554		    0xffffffff, PAGE_SIZE, 0);
555	if (addr == 0) {
556		printf("bktr%d: Unable to allocate %d bytes of memory.\n",
557			unit, size);
558	}
559
560	return( addr );
561}
562
563
564/*---------------------------------------------------------
565**
566**	BrookTree 848 character device driver routines
567**
568**---------------------------------------------------------
569*/
570
571#define VIDEO_DEV	0x00
572#define TUNER_DEV	0x01
573#define VBI_DEV		0x02
574
575#define UNIT(x)		((x) & 0x0f)
576#define FUNCTION(x)	(x >> 4)
577
578/*
579 *
580 */
581static int
582bktr_open( struct cdev *dev, int flags, int fmt, struct thread *td )
583{
584	bktr_ptr_t	bktr;
585	int		unit;
586	int		result;
587
588	unit = UNIT( minor(dev) );
589
590	/* Get the device data */
591	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
592	if (bktr == NULL) {
593		/* the device is no longer valid/functioning */
594		return (ENXIO);
595	}
596
597	if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
598		return( ENXIO );
599
600	/* Record that the device is now busy */
601	device_busy(devclass_get_device(bktr_devclass, unit));
602
603
604	if (bt848_card != -1) {
605	  if ((bt848_card >> 8   == unit ) &&
606	     ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
607	    if ( bktr->bt848_card != (bt848_card & 0xff) ) {
608	      bktr->bt848_card = (bt848_card & 0xff);
609	      probeCard(bktr, FALSE, unit);
610	    }
611	  }
612	}
613
614	if (bt848_tuner != -1) {
615	  if ((bt848_tuner >> 8   == unit ) &&
616	     ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
617	    if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
618	      bktr->bt848_tuner = (bt848_tuner & 0xff);
619	      probeCard(bktr, FALSE, unit);
620	    }
621	  }
622	}
623
624	if (bt848_reverse_mute != -1) {
625	  if ((bt848_reverse_mute >> 8)   == unit ) {
626	    bktr->reverse_mute = bt848_reverse_mute & 0xff;
627	  }
628	}
629
630	if (bt848_slow_msp_audio != -1) {
631	  if ((bt848_slow_msp_audio >> 8) == unit ) {
632	      bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
633	  }
634	}
635
636#ifdef BKTR_NEW_MSP34XX_DRIVER
637	if (bt848_stereo_once != 0) {
638	  if ((bt848_stereo_once >> 8) == unit ) {
639	      bktr->stereo_once = (bt848_stereo_once & 0xff);
640	  }
641	}
642
643	if (bt848_amsound != -1) {
644	  if ((bt848_amsound >> 8) == unit ) {
645	      bktr->amsound = (bt848_amsound & 0xff);
646	  }
647	}
648
649	if (bt848_dolby != -1) {
650	  if ((bt848_dolby >> 8) == unit ) {
651	      bktr->dolby = (bt848_dolby & 0xff);
652	  }
653	}
654#endif
655
656	switch ( FUNCTION( minor(dev) ) ) {
657	case VIDEO_DEV:
658		result = video_open( bktr );
659		break;
660	case TUNER_DEV:
661		result = tuner_open( bktr );
662		break;
663	case VBI_DEV:
664		result = vbi_open( bktr );
665		break;
666	default:
667		result = ENXIO;
668		break;
669	}
670
671	/* If there was an error opening the device, undo the busy status */
672	if (result != 0)
673		device_unbusy(devclass_get_device(bktr_devclass, unit));
674	return( result );
675}
676
677
678/*
679 *
680 */
681static int
682bktr_close( struct cdev *dev, int flags, int fmt, struct thread *td )
683{
684	bktr_ptr_t	bktr;
685	int		unit;
686	int		result;
687
688	unit = UNIT( minor(dev) );
689
690	/* Get the device data */
691	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
692	if (bktr == NULL) {
693		/* the device is no longer valid/functioning */
694		return (ENXIO);
695	}
696
697	switch ( FUNCTION( minor(dev) ) ) {
698	case VIDEO_DEV:
699		result = video_close( bktr );
700		break;
701	case TUNER_DEV:
702		result = tuner_close( bktr );
703		break;
704	case VBI_DEV:
705		result = vbi_close( bktr );
706		break;
707	default:
708		return (ENXIO);
709		break;
710	}
711
712	device_unbusy(devclass_get_device(bktr_devclass, unit));
713	return( result );
714}
715
716
717/*
718 *
719 */
720static int
721bktr_read( struct cdev *dev, struct uio *uio, int ioflag )
722{
723	bktr_ptr_t	bktr;
724	int		unit;
725
726	unit = UNIT(minor(dev));
727
728	/* Get the device data */
729	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
730	if (bktr == NULL) {
731		/* the device is no longer valid/functioning */
732		return (ENXIO);
733	}
734
735	switch ( FUNCTION( minor(dev) ) ) {
736	case VIDEO_DEV:
737		return( video_read( bktr, unit, dev, uio ) );
738	case VBI_DEV:
739		return( vbi_read( bktr, uio, ioflag ) );
740	}
741        return( ENXIO );
742}
743
744
745/*
746 *
747 */
748static int
749bktr_write( struct cdev *dev, struct uio *uio, int ioflag )
750{
751	return( EINVAL ); /* XXX or ENXIO ? */
752}
753
754
755/*
756 *
757 */
758static int
759bktr_ioctl( struct cdev *dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td )
760{
761	bktr_ptr_t	bktr;
762	int		unit;
763
764	unit = UNIT(minor(dev));
765
766	/* Get the device data */
767	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
768	if (bktr == NULL) {
769		/* the device is no longer valid/functioning */
770		return (ENXIO);
771	}
772
773	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
774		return( ENOMEM );
775
776	switch ( FUNCTION( minor(dev) ) ) {
777	case VIDEO_DEV:
778		return( video_ioctl( bktr, unit, cmd, arg, td ) );
779	case TUNER_DEV:
780		return( tuner_ioctl( bktr, unit, cmd, arg, td ) );
781	}
782
783	return( ENXIO );
784}
785
786
787/*
788 *
789 */
790static int
791bktr_mmap( struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot )
792{
793	int		unit;
794	bktr_ptr_t	bktr;
795
796	unit = UNIT(minor(dev));
797
798	if (FUNCTION(minor(dev)) > 0)	/* only allow mmap on /dev/bktr[n] */
799		return( -1 );
800
801	/* Get the device data */
802	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
803	if (bktr == NULL) {
804		/* the device is no longer valid/functioning */
805		return (ENXIO);
806	}
807
808	if (nprot & PROT_EXEC)
809		return( -1 );
810
811	if (offset < 0)
812		return( -1 );
813
814	if (offset >= bktr->alloc_pages * PAGE_SIZE)
815		return( -1 );
816
817	*paddr = vtophys(bktr->bigbuf) + offset;
818	return( 0 );
819}
820
821static int
822bktr_poll( struct cdev *dev, int events, struct thread *td)
823{
824	int		unit;
825	bktr_ptr_t	bktr;
826	int revents = 0;
827	DECLARE_INTR_MASK(s);
828
829	unit = UNIT(minor(dev));
830
831	/* Get the device data */
832	bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
833	if (bktr == NULL) {
834		/* the device is no longer valid/functioning */
835		return (ENXIO);
836	}
837
838	LOCK_VBI(bktr);
839	DISABLE_INTR(s);
840
841	if (events & (POLLIN | POLLRDNORM)) {
842
843		switch ( FUNCTION( minor(dev) ) ) {
844		case VBI_DEV:
845			if(bktr->vbisize == 0)
846				selrecord(td, &bktr->vbi_select);
847			else
848				revents |= events & (POLLIN | POLLRDNORM);
849			break;
850		}
851	}
852
853	ENABLE_INTR(s);
854	UNLOCK_VBI(bktr);
855
856	return (revents);
857}
858
859#endif		/* FreeBSD 4.x specific kernel interface routines */
860
861/*****************/
862/* *** BSDI  *** */
863/*****************/
864
865#if defined(__bsdi__)
866#endif		/* __bsdi__ BSDI specific kernel interface routines */
867
868
869/*****************************/
870/* *** OpenBSD / NetBSD  *** */
871/*****************************/
872#if defined(__NetBSD__) || defined(__OpenBSD__)
873
874#define IPL_VIDEO       IPL_BIO         /* XXX */
875
876static	int		bktr_intr(void *arg) { return common_bktr_intr(arg); }
877
878#define bktr_open       bktropen
879#define bktr_close      bktrclose
880#define bktr_read       bktrread
881#define bktr_write      bktrwrite
882#define bktr_ioctl      bktrioctl
883#define bktr_mmap       bktrmmap
884
885vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
886                                 vm_offset_t, vm_offset_t);
887
888#if defined(__OpenBSD__)
889static int      bktr_probe(struct device *, void *, void *);
890#else
891static int      bktr_probe(struct device *, struct cfdata *, void *);
892#endif
893static void     bktr_attach(struct device *, struct device *, void *);
894
895struct cfattach bktr_ca = {
896        sizeof(struct bktr_softc), bktr_probe, bktr_attach
897};
898
899#if defined(__NetBSD__)
900extern struct cfdriver bktr_cd;
901#else
902struct cfdriver bktr_cd = {
903        NULL, "bktr", DV_DULL
904};
905#endif
906
907int
908bktr_probe(parent, match, aux)
909	struct device *parent;
910#if defined(__OpenBSD__)
911        void *match;
912#else
913        struct cfdata *match;
914#endif
915        void *aux;
916{
917        struct pci_attach_args *pa = aux;
918
919        if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE &&
920            (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 ||
921             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 ||
922             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 ||
923             PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879))
924                return 1;
925
926        return 0;
927}
928
929
930/*
931 * the attach routine.
932 */
933static void
934bktr_attach(struct device *parent, struct device *self, void *aux)
935{
936	bktr_ptr_t	bktr;
937	u_long		latency;
938	u_long		fun;
939	unsigned int	rev;
940
941#if defined(__OpenBSD__)
942	struct pci_attach_args *pa = aux;
943	pci_chipset_tag_t pc = pa->pa_pc;
944
945	pci_intr_handle_t ih;
946	const char *intrstr;
947	int retval;
948	int unit;
949
950	bktr = (bktr_ptr_t)self;
951	unit = bktr->bktr_dev.dv_unit;
952
953	bktr->pc = pa->pa_pc;
954	bktr->tag = pa->pa_tag;
955        bktr->dmat = pa->pa_dmat;
956
957	/*
958	 * map memory
959	 */
960	bktr->memt = pa->pa_memt;
961	retval = pci_mem_find(pc, pa->pa_tag, PCI_MAPREG_START,
962			      &bktr->phys_base, &bktr->obmemsz, NULL);
963	if (!retval)
964		retval = bus_space_map(pa->pa_memt, bktr->phys_base,
965				       bktr->obmemsz, 0, &bktr->memh);
966	if (retval) {
967		printf(": couldn't map memory\n");
968		return;
969	}
970
971
972	/*
973	 * map interrupt
974	 */
975	if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
976			 pa->pa_intrline, &ih)) {
977		printf(": couldn't map interrupt\n");
978		return;
979	}
980	intrstr = pci_intr_string(pa->pa_pc, ih);
981
982	bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
983				      bktr_intr, bktr, bktr->bktr_dev.dv_xname);
984	if (bktr->ih == NULL) {
985		printf(": couldn't establish interrupt");
986		if (intrstr != NULL)
987			printf(" at %s", intrstr);
988		printf("\n");
989		return;
990	}
991
992	if (intrstr != NULL)
993		printf(": %s\n", intrstr);
994#endif /* __OpenBSD__ */
995
996#if defined(__NetBSD__)
997	struct pci_attach_args *pa = aux;
998	pci_intr_handle_t ih;
999	const char *intrstr;
1000	int retval;
1001	int unit;
1002
1003	bktr = (bktr_ptr_t)self;
1004	unit = bktr->bktr_dev.dv_unit;
1005        bktr->dmat = pa->pa_dmat;
1006
1007	printf("\n");
1008
1009	/*
1010	 * map memory
1011	 */
1012	retval = pci_mapreg_map(pa, PCI_MAPREG_START,
1013				PCI_MAPREG_TYPE_MEM
1014				| PCI_MAPREG_MEM_TYPE_32BIT, 0,
1015				&bktr->memt, &bktr->memh, NULL,
1016				&bktr->obmemsz);
1017	DPR(("pci_mapreg_map: memt %x, memh %x, size %x\n",
1018	     bktr->memt, (u_int)bktr->memh, (u_int)bktr->obmemsz));
1019	if (retval) {
1020		printf("%s: couldn't map memory\n", bktr_name(bktr));
1021		return;
1022	}
1023
1024	/*
1025	 * Disable the brooktree device
1026	 */
1027	OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1028	OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1029
1030	/*
1031	 * map interrupt
1032	 */
1033	if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
1034			 pa->pa_intrline, &ih)) {
1035		printf("%s: couldn't map interrupt\n",
1036		       bktr_name(bktr));
1037		return;
1038	}
1039	intrstr = pci_intr_string(pa->pa_pc, ih);
1040	bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
1041				      bktr_intr, bktr);
1042	if (bktr->ih == NULL) {
1043		printf("%s: couldn't establish interrupt",
1044		       bktr_name(bktr));
1045		if (intrstr != NULL)
1046			printf(" at %s", intrstr);
1047		printf("\n");
1048		return;
1049	}
1050	if (intrstr != NULL)
1051		printf("%s: interrupting at %s\n", bktr_name(bktr),
1052		       intrstr);
1053#endif /* __NetBSD__ */
1054
1055/*
1056 * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
1057 * you have more than four, then 16 would probably be a better value.
1058 */
1059#ifndef BROOKTREE_DEF_LATENCY_VALUE
1060#define BROOKTREE_DEF_LATENCY_VALUE	10
1061#endif
1062	latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER);
1063	latency = (latency >> 8) & 0xff;
1064
1065	if (!latency) {
1066		if (bootverbose) {
1067			printf("%s: PCI bus latency was 0 changing to %d",
1068			       bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE);
1069		}
1070		latency = BROOKTREE_DEF_LATENCY_VALUE;
1071		pci_conf_write(pa->pa_pc, pa->pa_tag,
1072			       PCI_LATENCY_TIMER, latency<<8);
1073	}
1074
1075
1076	/* Enabled Bus Master
1077	   XXX: check if all old DMA is stopped first (e.g. after warm
1078	   boot) */
1079	fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
1080	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
1081		       fun | PCI_COMMAND_MASTER_ENABLE);
1082
1083	/* read the pci id and determine the card type */
1084	fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
1085        rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff;
1086
1087	common_bktr_attach(bktr, unit, fun, rev);
1088}
1089
1090
1091/*
1092 * Special Memory Allocation
1093 */
1094vm_offset_t
1095get_bktr_mem(bktr, dmapp, size)
1096        bktr_ptr_t bktr;
1097        bus_dmamap_t *dmapp;
1098        unsigned int size;
1099{
1100        bus_dma_tag_t dmat = bktr->dmat;
1101        bus_dma_segment_t seg;
1102        bus_size_t align;
1103        int rseg;
1104        caddr_t kva;
1105
1106        /*
1107         * Allocate a DMA area
1108         */
1109        align = 1 << 24;
1110        if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1111                             &rseg, BUS_DMA_NOWAIT)) {
1112                align = PAGE_SIZE;
1113                if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1114                                     &rseg, BUS_DMA_NOWAIT)) {
1115                        printf("%s: Unable to dmamem_alloc of %d bytes\n",
1116			       bktr_name(bktr), size);
1117                        return 0;
1118                }
1119        }
1120        if (bus_dmamem_map(dmat, &seg, rseg, size,
1121                           &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
1122                printf("%s: Unable to dmamem_map of %d bytes\n",
1123                        bktr_name(bktr), size);
1124                bus_dmamem_free(dmat, &seg, rseg);
1125                return 0;
1126        }
1127#ifdef __OpenBSD__
1128        bktr->dm_mapsize = size;
1129#endif
1130        /*
1131         * Create and locd the DMA map for the DMA area
1132         */
1133        if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) {
1134                printf("%s: Unable to dmamap_create of %d bytes\n",
1135                        bktr_name(bktr), size);
1136                bus_dmamem_unmap(dmat, kva, size);
1137                bus_dmamem_free(dmat, &seg, rseg);
1138                return 0;
1139        }
1140        if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) {
1141                printf("%s: Unable to dmamap_load of %d bytes\n",
1142                        bktr_name(bktr), size);
1143                bus_dmamem_unmap(dmat, kva, size);
1144                bus_dmamem_free(dmat, &seg, rseg);
1145                bus_dmamap_destroy(dmat, *dmapp);
1146                return 0;
1147        }
1148        return (vm_offset_t)kva;
1149}
1150
1151void
1152free_bktr_mem(bktr, dmap, kva)
1153        bktr_ptr_t bktr;
1154        bus_dmamap_t dmap;
1155        vm_offset_t kva;
1156{
1157        bus_dma_tag_t dmat = bktr->dmat;
1158
1159#ifdef __NetBSD__
1160        bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize);
1161#else
1162        bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize);
1163#endif
1164        bus_dmamem_free(dmat, dmap->dm_segs, 1);
1165        bus_dmamap_destroy(dmat, dmap);
1166}
1167
1168
1169/*---------------------------------------------------------
1170**
1171**	BrookTree 848 character device driver routines
1172**
1173**---------------------------------------------------------
1174*/
1175
1176
1177#define VIDEO_DEV	0x00
1178#define TUNER_DEV	0x01
1179#define VBI_DEV		0x02
1180
1181#define UNIT(x)         (minor((x) & 0x0f))
1182#define FUNCTION(x)     (minor((x >> 4) & 0x0f))
1183
1184/*
1185 *
1186 */
1187int
1188bktr_open(dev_t dev, int flags, int fmt, struct thread *td)
1189{
1190	bktr_ptr_t	bktr;
1191	int		unit;
1192
1193	unit = UNIT(dev);
1194
1195	/* unit out of range */
1196	if ((unit > bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL))
1197		return(ENXIO);
1198
1199	bktr = bktr_cd.cd_devs[unit];
1200
1201	if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
1202		return(ENXIO);
1203
1204	switch (FUNCTION(dev)) {
1205	case VIDEO_DEV:
1206		return(video_open(bktr));
1207	case TUNER_DEV:
1208		return(tuner_open(bktr));
1209	case VBI_DEV:
1210		return(vbi_open(bktr));
1211	}
1212
1213	return(ENXIO);
1214}
1215
1216
1217/*
1218 *
1219 */
1220int
1221bktr_close(dev_t dev, int flags, int fmt, struct thread *td)
1222{
1223	bktr_ptr_t	bktr;
1224	int		unit;
1225
1226	unit = UNIT(dev);
1227
1228	bktr = bktr_cd.cd_devs[unit];
1229
1230	switch (FUNCTION(dev)) {
1231	case VIDEO_DEV:
1232		return(video_close(bktr));
1233	case TUNER_DEV:
1234		return(tuner_close(bktr));
1235	case VBI_DEV:
1236		return(vbi_close(bktr));
1237	}
1238
1239	return(ENXIO);
1240}
1241
1242/*
1243 *
1244 */
1245int
1246bktr_read(dev_t dev, struct uio *uio, int ioflag)
1247{
1248	bktr_ptr_t	bktr;
1249	int		unit;
1250
1251	unit = UNIT(dev);
1252
1253	bktr = bktr_cd.cd_devs[unit];
1254
1255	switch (FUNCTION(dev)) {
1256	case VIDEO_DEV:
1257		return(video_read(bktr, unit, dev, uio));
1258	case VBI_DEV:
1259		return(vbi_read(bktr, uio, ioflag));
1260	}
1261
1262        return(ENXIO);
1263}
1264
1265
1266/*
1267 *
1268 */
1269int
1270bktr_write(dev_t dev, struct uio *uio, int ioflag)
1271{
1272	/* operation not supported */
1273	return(EOPNOTSUPP);
1274}
1275
1276/*
1277 *
1278 */
1279int
1280bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td)
1281{
1282	bktr_ptr_t	bktr;
1283	int		unit;
1284
1285	unit = UNIT(dev);
1286
1287	bktr = bktr_cd.cd_devs[unit];
1288
1289	if (bktr->bigbuf == 0)	/* no frame buffer allocated (ioctl failed) */
1290		return(ENOMEM);
1291
1292	switch (FUNCTION(dev)) {
1293	case VIDEO_DEV:
1294		return(video_ioctl(bktr, unit, cmd, arg, pr));
1295	case TUNER_DEV:
1296		return(tuner_ioctl(bktr, unit, cmd, arg, pr));
1297	}
1298
1299	return(ENXIO);
1300}
1301
1302/*
1303 *
1304 */
1305paddr_t
1306bktr_mmap(dev_t dev, off_t offset, int nprot)
1307{
1308	int		unit;
1309	bktr_ptr_t	bktr;
1310
1311	unit = UNIT(dev);
1312
1313	if (FUNCTION(dev) > 0)	/* only allow mmap on /dev/bktr[n] */
1314		return(-1);
1315
1316	bktr = bktr_cd.cd_devs[unit];
1317
1318	if ((vaddr_t)offset < 0)
1319		return(-1);
1320
1321	if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE)
1322		return(-1);
1323
1324#ifdef __NetBSD__
1325	return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1,
1326				(vaddr_t)offset, nprot, BUS_DMA_WAITOK));
1327#else
1328	return(i386_btop(vtophys(bktr->bigbuf) + offset));
1329#endif
1330}
1331
1332#endif /* __NetBSD__ || __OpenBSD__ */
1333