FreeBSD/Linux Kernel Cross Reference
sys/dev/bktr/bktr_os.c
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: releng/5.2/sys/dev/bktr/bktr_os.c 123088 2003-12-01 19:03:50Z truckman $");
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/signalvar.h>
66 #include <sys/mman.h>
67 #include <sys/poll.h>
68 #if __FreeBSD_version >= 500014
69 #include <sys/selinfo.h>
70 #else
71 #include <sys/select.h>
72 #endif
73 #include <sys/vnode.h>
74
75 #include <vm/vm.h>
76 #include <vm/vm_kern.h>
77 #include <vm/pmap.h>
78 #include <vm/vm_extern.h>
79
80 #if (__FreeBSD_version >=400000)
81 #include <sys/bus.h> /* used by smbus and newbus */
82 #endif
83
84 #if (__FreeBSD_version >=300000)
85 #include <machine/bus_memio.h> /* used by bus space */
86 #include <machine/bus.h> /* used by bus space and newbus */
87 #include <sys/bus.h>
88 #endif
89
90 #if (__FreeBSD_version >=400000)
91 #include <sys/rman.h> /* used by newbus */
92 #include <machine/resource.h> /* used by newbus */
93 #endif
94
95 #if (__FreeBSD_version < 500000)
96 #include <machine/clock.h> /* for DELAY */
97 #include <pci/pcivar.h>
98 #include <pci/pcireg.h>
99 #else
100 #include <dev/pci/pcivar.h>
101 #include <dev/pci/pcireg.h>
102 #endif
103
104 #include <sys/sysctl.h>
105 int bt848_card = -1;
106 int bt848_tuner = -1;
107 int bt848_reverse_mute = -1;
108 int bt848_format = -1;
109 int bt848_slow_msp_audio = -1;
110 #ifdef BKTR_NEW_MSP34XX_DRIVER
111 int bt848_stereo_once = 0; /* no continuous stereo monitoring */
112 int bt848_amsound = 0; /* hard-wire AM sound at 6.5 Hz (france),
113 the autoscan seems work well only with FM... */
114 int bt848_dolby = 0;
115 #endif
116
117 SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
118 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
119 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
120 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
121 SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
122 SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
123 #ifdef BKTR_NEW_MSP34XX_DRIVER
124 SYSCTL_INT(_hw_bt848, OID_AUTO, stereo_once, CTLFLAG_RW, &bt848_stereo_once, 0, "");
125 SYSCTL_INT(_hw_bt848, OID_AUTO, amsound, CTLFLAG_RW, &bt848_amsound, 0, "");
126 SYSCTL_INT(_hw_bt848, OID_AUTO, dolby, CTLFLAG_RW, &bt848_dolby, 0, "");
127 #endif
128
129 #endif /* end freebsd section */
130
131
132
133 /****************/
134 /* *** BSDI *** */
135 /****************/
136 #ifdef __bsdi__
137 #endif /* __bsdi__ */
138
139
140 /**************************/
141 /* *** OpenBSD/NetBSD *** */
142 /**************************/
143 #if defined(__NetBSD__) || defined(__OpenBSD__)
144
145 #include <sys/param.h>
146 #include <sys/systm.h>
147 #include <sys/conf.h>
148 #include <sys/uio.h>
149 #include <sys/kernel.h>
150 #include <sys/signalvar.h>
151 #include <sys/mman.h>
152 #include <sys/poll.h>
153 #include <sys/select.h>
154 #include <sys/vnode.h>
155
156 #include <vm/vm.h>
157
158 #ifndef __NetBSD__
159 #include <vm/vm_kern.h>
160 #include <vm/pmap.h>
161 #include <vm/vm_extern.h>
162 #endif
163
164 #include <sys/device.h>
165 #include <dev/pci/pcivar.h>
166 #include <dev/pci/pcireg.h>
167 #include <dev/pci/pcidevs.h>
168
169 #define BKTR_DEBUG
170 #ifdef BKTR_DEBUG
171 int bktr_debug = 0;
172 #define DPR(x) (bktr_debug ? printf x : 0)
173 #else
174 #define DPR(x)
175 #endif
176 #endif /* __NetBSD__ || __OpenBSD__ */
177
178
179 #ifdef __NetBSD__
180 #include <dev/ic/bt8xx.h> /* NetBSD location for .h files */
181 #include <dev/pci/bktr/bktr_reg.h>
182 #include <dev/pci/bktr/bktr_tuner.h>
183 #include <dev/pci/bktr/bktr_card.h>
184 #include <dev/pci/bktr/bktr_audio.h>
185 #include <dev/pci/bktr/bktr_core.h>
186 #include <dev/pci/bktr/bktr_os.h>
187 #else /* Traditional location for .h files */
188 #include <machine/ioctl_meteor.h>
189 #include <machine/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
190 #include <dev/bktr/bktr_reg.h>
191 #include <dev/bktr/bktr_tuner.h>
192 #include <dev/bktr/bktr_card.h>
193 #include <dev/bktr/bktr_audio.h>
194 #include <dev/bktr/bktr_core.h>
195 #include <dev/bktr/bktr_os.h>
196
197 #if defined(BKTR_USE_FREEBSD_SMBUS)
198 #include <dev/bktr/bktr_i2c.h>
199
200 #include "iicbb_if.h"
201 #include "smbus_if.h"
202 #endif
203 #endif
204
205
206 /****************************/
207 /* *** FreeBSD 4.x code *** */
208 /****************************/
209 #if (__FreeBSD_version >= 400000)
210
211 static int bktr_probe( device_t dev );
212 static int bktr_attach( device_t dev );
213 static int bktr_detach( device_t dev );
214 static int bktr_shutdown( device_t dev );
215 static void bktr_intr(void *arg) { common_bktr_intr(arg); }
216
217 static device_method_t bktr_methods[] = {
218 /* Device interface */
219 DEVMETHOD(device_probe, bktr_probe),
220 DEVMETHOD(device_attach, bktr_attach),
221 DEVMETHOD(device_detach, bktr_detach),
222 DEVMETHOD(device_shutdown, bktr_shutdown),
223
224 #if defined(BKTR_USE_FREEBSD_SMBUS)
225 /* iicbb interface */
226 DEVMETHOD(iicbb_callback, bti2c_iic_callback),
227 DEVMETHOD(iicbb_setsda, bti2c_iic_setsda),
228 DEVMETHOD(iicbb_setscl, bti2c_iic_setscl),
229 DEVMETHOD(iicbb_getsda, bti2c_iic_getsda),
230 DEVMETHOD(iicbb_getscl, bti2c_iic_getscl),
231 DEVMETHOD(iicbb_reset, bti2c_iic_reset),
232
233 /* smbus interface */
234 DEVMETHOD(smbus_callback, bti2c_smb_callback),
235 DEVMETHOD(smbus_writeb, bti2c_smb_writeb),
236 DEVMETHOD(smbus_writew, bti2c_smb_writew),
237 DEVMETHOD(smbus_readb, bti2c_smb_readb),
238 #endif
239
240 { 0, 0 }
241 };
242
243 static driver_t bktr_driver = {
244 "bktr",
245 bktr_methods,
246 sizeof(struct bktr_softc),
247 };
248
249 static devclass_t bktr_devclass;
250
251 static d_open_t bktr_open;
252 static d_close_t bktr_close;
253 static d_read_t bktr_read;
254 static d_write_t bktr_write;
255 static d_ioctl_t bktr_ioctl;
256 static d_mmap_t bktr_mmap;
257 static d_poll_t bktr_poll;
258
259 #define CDEV_MAJOR 92
260 static struct cdevsw bktr_cdevsw = {
261 .d_open = bktr_open,
262 .d_close = bktr_close,
263 .d_read = bktr_read,
264 .d_write = bktr_write,
265 .d_ioctl = bktr_ioctl,
266 .d_poll = bktr_poll,
267 .d_mmap = bktr_mmap,
268 .d_name = "bktr",
269 .d_maj = CDEV_MAJOR,
270 };
271
272 DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
273 #if (__FreeBSD_version > 410000)
274 MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
275 MODULE_VERSION(bktr, 1);
276 #endif
277
278
279 /*
280 * the boot time probe routine.
281 */
282 static int
283 bktr_probe( device_t dev )
284 {
285 unsigned int type = pci_get_devid(dev);
286 unsigned int rev = pci_get_revid(dev);
287
288 if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
289 {
290 switch (PCI_PRODUCT(type)) {
291 case PCI_PRODUCT_BROOKTREE_BT848:
292 if (rev == 0x12)
293 device_set_desc(dev, "BrookTree 848A");
294 else
295 device_set_desc(dev, "BrookTree 848");
296 return 0;
297 case PCI_PRODUCT_BROOKTREE_BT849:
298 device_set_desc(dev, "BrookTree 849A");
299 return 0;
300 case PCI_PRODUCT_BROOKTREE_BT878:
301 device_set_desc(dev, "BrookTree 878");
302 return 0;
303 case PCI_PRODUCT_BROOKTREE_BT879:
304 device_set_desc(dev, "BrookTree 879");
305 return 0;
306 }
307 };
308
309 return ENXIO;
310 }
311
312
313 /*
314 * the attach routine.
315 */
316 static int
317 bktr_attach( device_t dev )
318 {
319 u_long latency;
320 u_long fun;
321 u_long val;
322 unsigned int rev;
323 unsigned int unit;
324 int error = 0;
325 #ifdef BROOKTREE_IRQ
326 u_long old_irq, new_irq;
327 #endif
328
329 struct bktr_softc *bktr = device_get_softc(dev);
330
331 unit = device_get_unit(dev);
332
333 /* build the device name for bktr_name() */
334 snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
335
336 /*
337 * Enable bus mastering and Memory Mapped device
338 */
339 val = pci_read_config(dev, PCIR_COMMAND, 4);
340 val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
341 pci_write_config(dev, PCIR_COMMAND, val, 4);
342
343 /*
344 * Map control/status registers.
345 */
346 bktr->mem_rid = PCIR_BAR(0);
347 bktr->res_mem = bus_alloc_resource(dev, SYS_RES_MEMORY, &bktr->mem_rid,
348 0, ~0, 1, RF_ACTIVE);
349
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(dev, SYS_RES_IRQ, &bktr->irq_rid,
380 0, ~0, 1, 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
470 fail:
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 */
482 static int
483 bktr_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 */
529 static int
530 bktr_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 */
545 vm_offset_t
546 get_bktr_mem( int unit, unsigned size )
547 {
548 vm_offset_t addr = 0;
549
550 addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24);
551 if (addr == 0)
552 addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE);
553 if (addr == 0) {
554 printf("bktr%d: Unable to allocate %d bytes of memory.\n",
555 unit, size);
556 }
557
558 return( addr );
559 }
560
561
562 /*---------------------------------------------------------
563 **
564 ** BrookTree 848 character device driver routines
565 **
566 **---------------------------------------------------------
567 */
568
569 #define VIDEO_DEV 0x00
570 #define TUNER_DEV 0x01
571 #define VBI_DEV 0x02
572
573 #define UNIT(x) ((x) & 0x0f)
574 #define FUNCTION(x) (x >> 4)
575
576 /*
577 *
578 */
579 static int
580 bktr_open( dev_t dev, int flags, int fmt, struct thread *td )
581 {
582 bktr_ptr_t bktr;
583 int unit;
584 int result;
585
586 unit = UNIT( minor(dev) );
587
588 /* Get the device data */
589 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
590 if (bktr == NULL) {
591 /* the device is no longer valid/functioning */
592 return (ENXIO);
593 }
594
595 if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
596 return( ENXIO );
597
598 /* Record that the device is now busy */
599 device_busy(devclass_get_device(bktr_devclass, unit));
600
601
602 if (bt848_card != -1) {
603 if ((bt848_card >> 8 == unit ) &&
604 ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
605 if ( bktr->bt848_card != (bt848_card & 0xff) ) {
606 bktr->bt848_card = (bt848_card & 0xff);
607 probeCard(bktr, FALSE, unit);
608 }
609 }
610 }
611
612 if (bt848_tuner != -1) {
613 if ((bt848_tuner >> 8 == unit ) &&
614 ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
615 if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
616 bktr->bt848_tuner = (bt848_tuner & 0xff);
617 probeCard(bktr, FALSE, unit);
618 }
619 }
620 }
621
622 if (bt848_reverse_mute != -1) {
623 if ((bt848_reverse_mute >> 8) == unit ) {
624 bktr->reverse_mute = bt848_reverse_mute & 0xff;
625 }
626 }
627
628 if (bt848_slow_msp_audio != -1) {
629 if ((bt848_slow_msp_audio >> 8) == unit ) {
630 bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
631 }
632 }
633
634 #ifdef BKTR_NEW_MSP34XX_DRIVER
635 if (bt848_stereo_once != 0) {
636 if ((bt848_stereo_once >> 8) == unit ) {
637 bktr->stereo_once = (bt848_stereo_once & 0xff);
638 }
639 }
640
641 if (bt848_amsound != -1) {
642 if ((bt848_amsound >> 8) == unit ) {
643 bktr->amsound = (bt848_amsound & 0xff);
644 }
645 }
646
647 if (bt848_dolby != -1) {
648 if ((bt848_dolby >> 8) == unit ) {
649 bktr->dolby = (bt848_dolby & 0xff);
650 }
651 }
652 #endif
653
654 switch ( FUNCTION( minor(dev) ) ) {
655 case VIDEO_DEV:
656 result = video_open( bktr );
657 break;
658 case TUNER_DEV:
659 result = tuner_open( bktr );
660 break;
661 case VBI_DEV:
662 result = vbi_open( bktr );
663 break;
664 default:
665 result = ENXIO;
666 break;
667 }
668
669 /* If there was an error opening the device, undo the busy status */
670 if (result != 0)
671 device_unbusy(devclass_get_device(bktr_devclass, unit));
672 return( result );
673 }
674
675
676 /*
677 *
678 */
679 static int
680 bktr_close( dev_t dev, int flags, int fmt, struct thread *td )
681 {
682 bktr_ptr_t bktr;
683 int unit;
684 int result;
685
686 unit = UNIT( minor(dev) );
687
688 /* Get the device data */
689 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
690 if (bktr == NULL) {
691 /* the device is no longer valid/functioning */
692 return (ENXIO);
693 }
694
695 switch ( FUNCTION( minor(dev) ) ) {
696 case VIDEO_DEV:
697 result = video_close( bktr );
698 break;
699 case TUNER_DEV:
700 result = tuner_close( bktr );
701 break;
702 case VBI_DEV:
703 result = vbi_close( bktr );
704 break;
705 default:
706 return (ENXIO);
707 break;
708 }
709
710 device_unbusy(devclass_get_device(bktr_devclass, unit));
711 return( result );
712 }
713
714
715 /*
716 *
717 */
718 static int
719 bktr_read( dev_t dev, struct uio *uio, int ioflag )
720 {
721 bktr_ptr_t bktr;
722 int unit;
723
724 unit = UNIT(minor(dev));
725
726 /* Get the device data */
727 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
728 if (bktr == NULL) {
729 /* the device is no longer valid/functioning */
730 return (ENXIO);
731 }
732
733 switch ( FUNCTION( minor(dev) ) ) {
734 case VIDEO_DEV:
735 return( video_read( bktr, unit, dev, uio ) );
736 case VBI_DEV:
737 return( vbi_read( bktr, uio, ioflag ) );
738 }
739 return( ENXIO );
740 }
741
742
743 /*
744 *
745 */
746 static int
747 bktr_write( dev_t dev, struct uio *uio, int ioflag )
748 {
749 return( EINVAL ); /* XXX or ENXIO ? */
750 }
751
752
753 /*
754 *
755 */
756 static int
757 bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td )
758 {
759 bktr_ptr_t bktr;
760 int unit;
761
762 unit = UNIT(minor(dev));
763
764 /* Get the device data */
765 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
766 if (bktr == NULL) {
767 /* the device is no longer valid/functioning */
768 return (ENXIO);
769 }
770
771 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
772 return( ENOMEM );
773
774 switch ( FUNCTION( minor(dev) ) ) {
775 case VIDEO_DEV:
776 return( video_ioctl( bktr, unit, cmd, arg, td ) );
777 case TUNER_DEV:
778 return( tuner_ioctl( bktr, unit, cmd, arg, td ) );
779 }
780
781 return( ENXIO );
782 }
783
784
785 /*
786 *
787 */
788 static int
789 bktr_mmap( dev_t dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot )
790 {
791 int unit;
792 bktr_ptr_t bktr;
793
794 unit = UNIT(minor(dev));
795
796 if (FUNCTION(minor(dev)) > 0) /* only allow mmap on /dev/bktr[n] */
797 return( -1 );
798
799 /* Get the device data */
800 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
801 if (bktr == NULL) {
802 /* the device is no longer valid/functioning */
803 return (ENXIO);
804 }
805
806 if (nprot & PROT_EXEC)
807 return( -1 );
808
809 if (offset < 0)
810 return( -1 );
811
812 if (offset >= bktr->alloc_pages * PAGE_SIZE)
813 return( -1 );
814
815 *paddr = vtophys(bktr->bigbuf) + offset;
816 return( 0 );
817 }
818
819 static int
820 bktr_poll( dev_t dev, int events, struct thread *td)
821 {
822 int unit;
823 bktr_ptr_t bktr;
824 int revents = 0;
825 DECLARE_INTR_MASK(s);
826
827 unit = UNIT(minor(dev));
828
829 /* Get the device data */
830 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
831 if (bktr == NULL) {
832 /* the device is no longer valid/functioning */
833 return (ENXIO);
834 }
835
836 LOCK_VBI(bktr);
837 DISABLE_INTR(s);
838
839 if (events & (POLLIN | POLLRDNORM)) {
840
841 switch ( FUNCTION( minor(dev) ) ) {
842 case VBI_DEV:
843 if(bktr->vbisize == 0)
844 selrecord(td, &bktr->vbi_select);
845 else
846 revents |= events & (POLLIN | POLLRDNORM);
847 break;
848 }
849 }
850
851 ENABLE_INTR(s);
852 UNLOCK_VBI(bktr);
853
854 return (revents);
855 }
856
857 #endif /* FreeBSD 4.x specific kernel interface routines */
858
859 /*****************/
860 /* *** BSDI *** */
861 /*****************/
862
863 #if defined(__bsdi__)
864 #endif /* __bsdi__ BSDI specific kernel interface routines */
865
866
867 /*****************************/
868 /* *** OpenBSD / NetBSD *** */
869 /*****************************/
870 #if defined(__NetBSD__) || defined(__OpenBSD__)
871
872 #define IPL_VIDEO IPL_BIO /* XXX */
873
874 static int bktr_intr(void *arg) { return common_bktr_intr(arg); }
875
876 #define bktr_open bktropen
877 #define bktr_close bktrclose
878 #define bktr_read bktrread
879 #define bktr_write bktrwrite
880 #define bktr_ioctl bktrioctl
881 #define bktr_mmap bktrmmap
882
883 vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
884 vm_offset_t, vm_offset_t);
885
886 #if defined(__OpenBSD__)
887 static int bktr_probe(struct device *, void *, void *);
888 #else
889 static int bktr_probe(struct device *, struct cfdata *, void *);
890 #endif
891 static void bktr_attach(struct device *, struct device *, void *);
892
893 struct cfattach bktr_ca = {
894 sizeof(struct bktr_softc), bktr_probe, bktr_attach
895 };
896
897 #if defined(__NetBSD__)
898 extern struct cfdriver bktr_cd;
899 #else
900 struct cfdriver bktr_cd = {
901 NULL, "bktr", DV_DULL
902 };
903 #endif
904
905 int
906 bktr_probe(parent, match, aux)
907 struct device *parent;
908 #if defined(__OpenBSD__)
909 void *match;
910 #else
911 struct cfdata *match;
912 #endif
913 void *aux;
914 {
915 struct pci_attach_args *pa = aux;
916
917 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE &&
918 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 ||
919 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 ||
920 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 ||
921 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879))
922 return 1;
923
924 return 0;
925 }
926
927
928 /*
929 * the attach routine.
930 */
931 static void
932 bktr_attach(struct device *parent, struct device *self, void *aux)
933 {
934 bktr_ptr_t bktr;
935 u_long latency;
936 u_long fun;
937 unsigned int rev;
938
939 #if defined(__OpenBSD__)
940 struct pci_attach_args *pa = aux;
941 pci_chipset_tag_t pc = pa->pa_pc;
942
943 pci_intr_handle_t ih;
944 const char *intrstr;
945 int retval;
946 int unit;
947
948 bktr = (bktr_ptr_t)self;
949 unit = bktr->bktr_dev.dv_unit;
950
951 bktr->pc = pa->pa_pc;
952 bktr->tag = pa->pa_tag;
953 bktr->dmat = pa->pa_dmat;
954
955 /*
956 * map memory
957 */
958 bktr->memt = pa->pa_memt;
959 retval = pci_mem_find(pc, pa->pa_tag, PCI_MAPREG_START,
960 &bktr->phys_base, &bktr->obmemsz, NULL);
961 if (!retval)
962 retval = bus_space_map(pa->pa_memt, bktr->phys_base,
963 bktr->obmemsz, 0, &bktr->memh);
964 if (retval) {
965 printf(": couldn't map memory\n");
966 return;
967 }
968
969
970 /*
971 * map interrupt
972 */
973 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
974 pa->pa_intrline, &ih)) {
975 printf(": couldn't map interrupt\n");
976 return;
977 }
978 intrstr = pci_intr_string(pa->pa_pc, ih);
979
980 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
981 bktr_intr, bktr, bktr->bktr_dev.dv_xname);
982 if (bktr->ih == NULL) {
983 printf(": couldn't establish interrupt");
984 if (intrstr != NULL)
985 printf(" at %s", intrstr);
986 printf("\n");
987 return;
988 }
989
990 if (intrstr != NULL)
991 printf(": %s\n", intrstr);
992 #endif /* __OpenBSD__ */
993
994 #if defined(__NetBSD__)
995 struct pci_attach_args *pa = aux;
996 pci_intr_handle_t ih;
997 const char *intrstr;
998 int retval;
999 int unit;
1000
1001 bktr = (bktr_ptr_t)self;
1002 unit = bktr->bktr_dev.dv_unit;
1003 bktr->dmat = pa->pa_dmat;
1004
1005 printf("\n");
1006
1007 /*
1008 * map memory
1009 */
1010 retval = pci_mapreg_map(pa, PCI_MAPREG_START,
1011 PCI_MAPREG_TYPE_MEM
1012 | PCI_MAPREG_MEM_TYPE_32BIT, 0,
1013 &bktr->memt, &bktr->memh, NULL,
1014 &bktr->obmemsz);
1015 DPR(("pci_mapreg_map: memt %x, memh %x, size %x\n",
1016 bktr->memt, (u_int)bktr->memh, (u_int)bktr->obmemsz));
1017 if (retval) {
1018 printf("%s: couldn't map memory\n", bktr_name(bktr));
1019 return;
1020 }
1021
1022 /*
1023 * Disable the brooktree device
1024 */
1025 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
1026 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
1027
1028 /*
1029 * map interrupt
1030 */
1031 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
1032 pa->pa_intrline, &ih)) {
1033 printf("%s: couldn't map interrupt\n",
1034 bktr_name(bktr));
1035 return;
1036 }
1037 intrstr = pci_intr_string(pa->pa_pc, ih);
1038 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
1039 bktr_intr, bktr);
1040 if (bktr->ih == NULL) {
1041 printf("%s: couldn't establish interrupt",
1042 bktr_name(bktr));
1043 if (intrstr != NULL)
1044 printf(" at %s", intrstr);
1045 printf("\n");
1046 return;
1047 }
1048 if (intrstr != NULL)
1049 printf("%s: interrupting at %s\n", bktr_name(bktr),
1050 intrstr);
1051 #endif /* __NetBSD__ */
1052
1053 /*
1054 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if
1055 * you have more than four, then 16 would probably be a better value.
1056 */
1057 #ifndef BROOKTREE_DEF_LATENCY_VALUE
1058 #define BROOKTREE_DEF_LATENCY_VALUE 10
1059 #endif
1060 latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER);
1061 latency = (latency >> 8) & 0xff;
1062
1063 if (!latency) {
1064 if (bootverbose) {
1065 printf("%s: PCI bus latency was 0 changing to %d",
1066 bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE);
1067 }
1068 latency = BROOKTREE_DEF_LATENCY_VALUE;
1069 pci_conf_write(pa->pa_pc, pa->pa_tag,
1070 PCI_LATENCY_TIMER, latency<<8);
1071 }
1072
1073
1074 /* Enabled Bus Master
1075 XXX: check if all old DMA is stopped first (e.g. after warm
1076 boot) */
1077 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
1078 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
1079 fun | PCI_COMMAND_MASTER_ENABLE);
1080
1081 /* read the pci id and determine the card type */
1082 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
1083 rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff;
1084
1085 common_bktr_attach(bktr, unit, fun, rev);
1086 }
1087
1088
1089 /*
1090 * Special Memory Allocation
1091 */
1092 vm_offset_t
1093 get_bktr_mem(bktr, dmapp, size)
1094 bktr_ptr_t bktr;
1095 bus_dmamap_t *dmapp;
1096 unsigned int size;
1097 {
1098 bus_dma_tag_t dmat = bktr->dmat;
1099 bus_dma_segment_t seg;
1100 bus_size_t align;
1101 int rseg;
1102 caddr_t kva;
1103
1104 /*
1105 * Allocate a DMA area
1106 */
1107 align = 1 << 24;
1108 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1109 &rseg, BUS_DMA_NOWAIT)) {
1110 align = PAGE_SIZE;
1111 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
1112 &rseg, BUS_DMA_NOWAIT)) {
1113 printf("%s: Unable to dmamem_alloc of %d bytes\n",
1114 bktr_name(bktr), size);
1115 return 0;
1116 }
1117 }
1118 if (bus_dmamem_map(dmat, &seg, rseg, size,
1119 &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
1120 printf("%s: Unable to dmamem_map of %d bytes\n",
1121 bktr_name(bktr), size);
1122 bus_dmamem_free(dmat, &seg, rseg);
1123 return 0;
1124 }
1125 #ifdef __OpenBSD__
1126 bktr->dm_mapsize = size;
1127 #endif
1128 /*
1129 * Create and locd the DMA map for the DMA area
1130 */
1131 if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) {
1132 printf("%s: Unable to dmamap_create of %d bytes\n",
1133 bktr_name(bktr), size);
1134 bus_dmamem_unmap(dmat, kva, size);
1135 bus_dmamem_free(dmat, &seg, rseg);
1136 return 0;
1137 }
1138 if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) {
1139 printf("%s: Unable to dmamap_load of %d bytes\n",
1140 bktr_name(bktr), size);
1141 bus_dmamem_unmap(dmat, kva, size);
1142 bus_dmamem_free(dmat, &seg, rseg);
1143 bus_dmamap_destroy(dmat, *dmapp);
1144 return 0;
1145 }
1146 return (vm_offset_t)kva;
1147 }
1148
1149 void
1150 free_bktr_mem(bktr, dmap, kva)
1151 bktr_ptr_t bktr;
1152 bus_dmamap_t dmap;
1153 vm_offset_t kva;
1154 {
1155 bus_dma_tag_t dmat = bktr->dmat;
1156
1157 #ifdef __NetBSD__
1158 bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize);
1159 #else
1160 bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize);
1161 #endif
1162 bus_dmamem_free(dmat, dmap->dm_segs, 1);
1163 bus_dmamap_destroy(dmat, dmap);
1164 }
1165
1166
1167 /*---------------------------------------------------------
1168 **
1169 ** BrookTree 848 character device driver routines
1170 **
1171 **---------------------------------------------------------
1172 */
1173
1174
1175 #define VIDEO_DEV 0x00
1176 #define TUNER_DEV 0x01
1177 #define VBI_DEV 0x02
1178
1179 #define UNIT(x) (minor((x) & 0x0f))
1180 #define FUNCTION(x) (minor((x >> 4) & 0x0f))
1181
1182 /*
1183 *
1184 */
1185 int
1186 bktr_open(dev_t dev, int flags, int fmt, struct thread *td)
1187 {
1188 bktr_ptr_t bktr;
1189 int unit;
1190
1191 unit = UNIT(dev);
1192
1193 /* unit out of range */
1194 if ((unit > bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL))
1195 return(ENXIO);
1196
1197 bktr = bktr_cd.cd_devs[unit];
1198
1199 if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
1200 return(ENXIO);
1201
1202 switch (FUNCTION(dev)) {
1203 case VIDEO_DEV:
1204 return(video_open(bktr));
1205 case TUNER_DEV:
1206 return(tuner_open(bktr));
1207 case VBI_DEV:
1208 return(vbi_open(bktr));
1209 }
1210
1211 return(ENXIO);
1212 }
1213
1214
1215 /*
1216 *
1217 */
1218 int
1219 bktr_close(dev_t dev, int flags, int fmt, struct thread *td)
1220 {
1221 bktr_ptr_t bktr;
1222 int unit;
1223
1224 unit = UNIT(dev);
1225
1226 bktr = bktr_cd.cd_devs[unit];
1227
1228 switch (FUNCTION(dev)) {
1229 case VIDEO_DEV:
1230 return(video_close(bktr));
1231 case TUNER_DEV:
1232 return(tuner_close(bktr));
1233 case VBI_DEV:
1234 return(vbi_close(bktr));
1235 }
1236
1237 return(ENXIO);
1238 }
1239
1240 /*
1241 *
1242 */
1243 int
1244 bktr_read(dev_t dev, struct uio *uio, int ioflag)
1245 {
1246 bktr_ptr_t bktr;
1247 int unit;
1248
1249 unit = UNIT(dev);
1250
1251 bktr = bktr_cd.cd_devs[unit];
1252
1253 switch (FUNCTION(dev)) {
1254 case VIDEO_DEV:
1255 return(video_read(bktr, unit, dev, uio));
1256 case VBI_DEV:
1257 return(vbi_read(bktr, uio, ioflag));
1258 }
1259
1260 return(ENXIO);
1261 }
1262
1263
1264 /*
1265 *
1266 */
1267 int
1268 bktr_write(dev_t dev, struct uio *uio, int ioflag)
1269 {
1270 /* operation not supported */
1271 return(EOPNOTSUPP);
1272 }
1273
1274 /*
1275 *
1276 */
1277 int
1278 bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td)
1279 {
1280 bktr_ptr_t bktr;
1281 int unit;
1282
1283 unit = UNIT(dev);
1284
1285 bktr = bktr_cd.cd_devs[unit];
1286
1287 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */
1288 return(ENOMEM);
1289
1290 switch (FUNCTION(dev)) {
1291 case VIDEO_DEV:
1292 return(video_ioctl(bktr, unit, cmd, arg, pr));
1293 case TUNER_DEV:
1294 return(tuner_ioctl(bktr, unit, cmd, arg, pr));
1295 }
1296
1297 return(ENXIO);
1298 }
1299
1300 /*
1301 *
1302 */
1303 paddr_t
1304 bktr_mmap(dev_t dev, off_t offset, int nprot)
1305 {
1306 int unit;
1307 bktr_ptr_t bktr;
1308
1309 unit = UNIT(dev);
1310
1311 if (FUNCTION(dev) > 0) /* only allow mmap on /dev/bktr[n] */
1312 return(-1);
1313
1314 bktr = bktr_cd.cd_devs[unit];
1315
1316 if ((vaddr_t)offset < 0)
1317 return(-1);
1318
1319 if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE)
1320 return(-1);
1321
1322 #ifdef __NetBSD__
1323 return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1,
1324 (vaddr_t)offset, nprot, BUS_DMA_WAITOK));
1325 #else
1326 return(i386_btop(vtophys(bktr->bigbuf) + offset));
1327 #endif
1328 }
1329
1330 #endif /* __NetBSD__ || __OpenBSD__ */
Cache object: d013525d785deeb540ced8e6e6c3df47
|