? lala Index: bktr_audio.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_audio.c,v retrieving revision 1.7 diff -u -p -r1.7 bktr_audio.c --- bktr_audio.c 12 Mar 2003 01:01:42 -0000 1.7 +++ bktr_audio.c 20 Mar 2003 02:13:15 -0000 @@ -91,11 +91,11 @@ __KERNEL_RCSID(0, "$NetBSD: bktr_audio.c #endif /* - * Prototypes for the GV_BCTV specific functions. + * Prototypes for the GV_BCTV2 specific functions. */ -void set_bctv_audio(bktr_ptr_t bktr); -void bctv_gpio_write(bktr_ptr_t bktr, int port, int val); -/*int bctv_gpio_read(bktr_ptr_t bktr, int port);*/ /* Not used */ +void set_bctv2_audio(bktr_ptr_t bktr); +void bctv2_gpio_write(bktr_ptr_t bktr, int port, int val); +/*int bctv2_gpio_read(bktr_ptr_t bktr, int port);*/ /* Not used */ @@ -177,8 +177,8 @@ set_audio(bktr_ptr_t bktr, int cmd) * audio source. The I/O_GV card has a more advanced multiplexer * and requires special handling. */ - if (bktr->bt848_card == CARD_IO_GV) { - set_bctv_audio(bktr); + if (bktr->bt848_card == CARD_IO_BCTV2) { + set_bctv2_audio(bktr); return(0); } @@ -321,87 +321,87 @@ set_BTSC(bktr_ptr_t bktr, int control) } /* - * CARD_GV_BCTV specific functions. + * CARD_GV_BCTV2 specific functions. */ -#define BCTV_AUDIO_MAIN 0x10 /* main audio program */ -#define BCTV_AUDIO_SUB 0x20 /* sub audio program */ -#define BCTV_AUDIO_BOTH 0x30 /* main(L) + sub(R) program */ - -#define BCTV_GPIO_REG0 1 -#define BCTV_GPIO_REG1 3 - -#define BCTV_GR0_AUDIO_MODE 3 -#define BCTV_GR0_AUDIO_MAIN 0 /* main program */ -#define BCTV_GR0_AUDIO_SUB 3 /* sub program */ -#define BCTV_GR0_AUDIO_BOTH 1 /* main(L) + sub(R) */ -#define BCTV_GR0_AUDIO_MUTE 4 /* audio mute */ -#define BCTV_GR0_AUDIO_MONO 8 /* force mono */ +#define BCTV2_AUDIO_MAIN 0x10 /* main audio program */ +#define BCTV2_AUDIO_SUB 0x20 /* sub audio program */ +#define BCTV2_AUDIO_BOTH 0x30 /* main(L) + sub(R) program */ + +#define BCTV2_GPIO_REG0 1 +#define BCTV2_GPIO_REG1 3 + +#define BCTV2_GR0_AUDIO_MODE 3 +#define BCTV2_GR0_AUDIO_MAIN 0 /* main program */ +#define BCTV2_GR0_AUDIO_SUB 3 /* sub program */ +#define BCTV2_GR0_AUDIO_BOTH 1 /* main(L) + sub(R) */ +#define BCTV2_GR0_AUDIO_MUTE 4 /* audio mute */ +#define BCTV2_GR0_AUDIO_MONO 8 /* force mono */ void -set_bctv_audio(bktr_ptr_t bktr) +set_bctv2_audio(bktr_ptr_t bktr) { int data; switch (bktr->audio_mux_select) { case 1: /* external */ case 2: /* internal */ - bctv_gpio_write(bktr, BCTV_GPIO_REG1, 0); + bctv2_gpio_write(bktr, BCTV2_GPIO_REG1, 0); break; default: /* tuner */ - bctv_gpio_write(bktr, BCTV_GPIO_REG1, 1); + bctv2_gpio_write(bktr, BCTV2_GPIO_REG1, 1); break; } /* switch (bktr->audio_sap_select) { */ - switch (BCTV_AUDIO_BOTH) { - case BCTV_AUDIO_SUB: - data = BCTV_GR0_AUDIO_SUB; + switch (BCTV2_AUDIO_BOTH) { + case BCTV2_AUDIO_SUB: + data = BCTV2_GR0_AUDIO_SUB; break; - case BCTV_AUDIO_BOTH: - data = BCTV_GR0_AUDIO_BOTH; + case BCTV2_AUDIO_BOTH: + data = BCTV2_GR0_AUDIO_BOTH; break; - case BCTV_AUDIO_MAIN: + case BCTV2_AUDIO_MAIN: default: - data = BCTV_GR0_AUDIO_MAIN; + data = BCTV2_GR0_AUDIO_MAIN; break; } if (bktr->audio_mute_state == TRUE) - data |= BCTV_GR0_AUDIO_MUTE; + data |= BCTV2_GR0_AUDIO_MUTE; - bctv_gpio_write(bktr, BCTV_GPIO_REG0, data); + bctv2_gpio_write(bktr, BCTV2_GPIO_REG0, data); return; } /* gpio_data bit assignment */ -#define BCTV_GPIO_ADDR_MASK 0x000300 -#define BCTV_GPIO_WE 0x000400 -#define BCTV_GPIO_OE 0x000800 -#define BCTV_GPIO_VAL_MASK 0x00f000 - -#define BCTV_GPIO_PORT_MASK 3 -#define BCTV_GPIO_ADDR_SHIFT 8 -#define BCTV_GPIO_VAL_SHIFT 12 +#define BCTV2_GPIO_ADDR_MASK 0x000300 +#define BCTV2_GPIO_WE 0x000400 +#define BCTV2_GPIO_OE 0x000800 +#define BCTV2_GPIO_VAL_MASK 0x00f000 + +#define BCTV2_GPIO_PORT_MASK 3 +#define BCTV2_GPIO_ADDR_SHIFT 8 +#define BCTV2_GPIO_VAL_SHIFT 12 /* gpio_out_en value for read/write */ -#define BCTV_GPIO_OUT_RMASK 0x000f00 -#define BCTV_GPIO_OUT_WMASK 0x00ff00 +#define BCTV2_GPIO_OUT_RMASK 0x000f00 +#define BCTV2_GPIO_OUT_WMASK 0x00ff00 -#define BCTV_BITS 100 +#define BCTV2_BITS 100 void -bctv_gpio_write(bktr_ptr_t bktr, int port, int val) +bctv2_gpio_write(bktr_ptr_t bktr, int port, int val) { u_long data, outbits; - port &= BCTV_GPIO_PORT_MASK; + port &= BCTV2_GPIO_PORT_MASK; switch (port) { case 1: case 3: - data = ((val << BCTV_GPIO_VAL_SHIFT) & BCTV_GPIO_VAL_MASK) | - ((port << BCTV_GPIO_ADDR_SHIFT) & BCTV_GPIO_ADDR_MASK) | - BCTV_GPIO_WE | BCTV_GPIO_OE; - outbits = BCTV_GPIO_OUT_WMASK; + data = ((val << BCTV2_GPIO_VAL_SHIFT) & BCTV2_GPIO_VAL_MASK) | + ((port << BCTV2_GPIO_ADDR_SHIFT) & BCTV2_GPIO_ADDR_MASK) | + BCTV2_GPIO_WE | BCTV2_GPIO_OE; + outbits = BCTV2_GPIO_OUT_WMASK; break; default: return; @@ -409,28 +409,28 @@ bctv_gpio_write(bktr_ptr_t bktr, int por OUTL(bktr, BKTR_GPIO_OUT_EN, 0); OUTL(bktr, BKTR_GPIO_DATA, data); OUTL(bktr, BKTR_GPIO_OUT_EN, outbits); - DELAY(BCTV_BITS); - OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV_GPIO_WE); - DELAY(BCTV_BITS); + DELAY(BCTV2_BITS); + OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV2_GPIO_WE); + DELAY(BCTV2_BITS); OUTL(bktr, BKTR_GPIO_DATA, data); - DELAY(BCTV_BITS); + DELAY(BCTV2_BITS); OUTL(bktr, BKTR_GPIO_DATA, ~0); OUTL(bktr, BKTR_GPIO_OUT_EN, 0); } /* Not yet used int -bctv_gpio_read(bktr_ptr_t bktr, int port) +bctv2_gpio_read(bktr_ptr_t bktr, int port) { u_long data, outbits, ret; - port &= BCTV_GPIO_PORT_MASK; + port &= BCTV2_GPIO_PORT_MASK; switch (port) { case 1: case 3: - data = ((port << BCTV_GPIO_ADDR_SHIFT) & BCTV_GPIO_ADDR_MASK) | - BCTV_GPIO_WE | BCTV_GPIO_OE; - outbits = BCTV_GPIO_OUT_RMASK; + data = ((port << BCTV2_GPIO_ADDR_SHIFT) & BCTV2_GPIO_ADDR_MASK) | + BCTV2_GPIO_WE | BCTV2_GPIO_OE; + outbits = BCTV2_GPIO_OUT_RMASK; break; default: return(-1); @@ -438,16 +438,16 @@ bctv_gpio_read(bktr_ptr_t bktr, int port OUTL(bktr, BKTR_GPIO_OUT_EN, 0); OUTL(bktr, BKTR_GPIO_DATA, data); OUTL(bktr, BKTR_GPIO_OUT_EN, outbits); - DELAY(BCTV_BITS); - OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV_GPIO_OE); - DELAY(BCTV_BITS); + DELAY(BCTV2_BITS); + OUTL(bktr, BKTR_GPIO_DATA, data & ~BCTV2_GPIO_OE); + DELAY(BCTV2_BITS); ret = INL(bktr, BKTR_GPIO_DATA); - DELAY(BCTV_BITS); + DELAY(BCTV2_BITS); OUTL(bktr, BKTR_GPIO_DATA, data); - DELAY(BCTV_BITS); + DELAY(BCTV2_BITS); OUTL(bktr, BKTR_GPIO_DATA, ~0); OUTL(bktr, BKTR_GPIO_OUT_EN, 0); - return((ret & BCTV_GPIO_VAL_MASK) >> BCTV_GPIO_VAL_SHIFT); + return((ret & BCTV2_GPIO_VAL_MASK) >> BCTV2_GPIO_VAL_SHIFT); } */ Index: bktr_card.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_card.c,v retrieving revision 1.3 diff -u -p -r1.3 bktr_card.c --- bktr_card.c 11 Mar 2003 23:11:21 -0000 1.3 +++ bktr_card.c 20 Mar 2003 02:13:29 -0000 @@ -51,8 +51,9 @@ */ #include +#ifdef __NetBSD__ __KERNEL_RCSID(0, "$NetBSD: bktr_card.c,v 1.14 2003/01/14 11:09:40 wiz Exp $"); - +#endif #include "opt_bktr.h" /* Include any kernel config options */ #include @@ -132,7 +133,9 @@ __KERNEL_RCSID(0, "$NetBSD: bktr_card.c, #define DEFAULT_TUNER PHILIPS_NTSC #endif - +#ifdef __FreeBSD__ +#define PCI_VENDOR_TERRATEC 0x153b +#endif /* @@ -251,7 +254,7 @@ static const struct CARDTYPE cards[] = { { 0x01, 0x02, 0x01, 0x00, 1 }, /* audio MUX values */ 0x0f }, /* GPIO mask */ - { CARD_IO_GV, /* the card id */ + { CARD_IO_BCTV2, /* the card id */ "I/O DATA GV-BCTV2/PCI", /* the 'name' */ NULL, /* the tuner */ 0, /* the tuner i2c address */ @@ -347,6 +350,18 @@ static const struct CARDTYPE cards[] = { 0, /* EEProm size */ { 0x20000, 0x00000, 0x30000, 0x40000, 1 }, /* audio MUX values*/ 0x70000 }, /* GPIO mask */ + { CARD_IO_BCTV3, /* the card id */ + "I/O DATA GV-BCTV3/PCI", /* the 'name' */ + NULL, /* the tuner */ + 0, /* the tuner i2c address */ + 0, /* dbx is optional */ + 0, + 0, + 0, /* EEProm type */ + 0, /* EEProm size */ + /* Tuner, Extern, Intern, Mute, Enabled */ + { 0x10000, 0, 0x10000, 0, 1 }, /* audio MUX values */ + 0x10f00 }, /* GPIO mask */ }; @@ -548,6 +563,10 @@ static int locate_eeprom_address(bktr_pt #define PCI_VENDOR_FLYVIDEO_2 0x1852 #define PCI_VENDOR_PINNACLE_ALT 0xBD11 +#define PCI_VENDOR_IODATA 0x10fc + +#define MODEL_IODATA_GV_BCTV3_PCI 0x4020 + void probeCard(bktr_ptr_t bktr, int verbose, int unit) { @@ -689,6 +708,14 @@ probeCard(bktr_ptr_t bktr, int verbose, bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE); goto checkTuner; } + + if (subsystem_vendor_id == 0x10fc && + subsystem_id == 0x4020) { + bktr->card = cards[ (card = CARD_IO_BCTV3) ]; + bktr->card.eepromAddr = eeprom_i2c_address; + bktr->card.eepromSize = (u_char)(256 / EEPROMBLOCKSIZE); + goto checkTuner; + } /* Vendor is unknown. We will use the standard probe code */ /* which may not give best results */ Index: bktr_card.h =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_card.h,v retrieving revision 1.3 diff -u -p -r1.3 bktr_card.h --- bktr_card.h 11 Mar 2003 23:11:22 -0000 1.3 +++ bktr_card.h 20 Mar 2003 02:13:31 -0000 @@ -71,7 +71,7 @@ #define CARD_AVER_MEDIA 6 #define CARD_OSPREY 7 #define CARD_NEC_PK 8 -#define CARD_IO_GV 9 +#define CARD_IO_BCTV2 9 #define CARD_FLYVIDEO 10 #define CARD_ZOLTRIX 11 #define CARD_KISS 12 @@ -79,7 +79,8 @@ #define CARD_ASKEY_DYNALINK_MAGIC_TVIEW 14 #define CARD_LEADTEK 15 #define CARD_TERRATVPLUS 16 -#define Bt848_MAX_CARD 17 +#define CARD_IO_BCTV3 17 +#define Bt848_MAX_CARD 18 int signCard(bktr_ptr_t bktr, int offset, int count, u_char* sig); Index: bktr_core.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_core.c,v retrieving revision 1.6 diff -u -p -r1.6 bktr_core.c --- bktr_core.c 11 Mar 2003 23:11:22 -0000 1.6 +++ bktr_core.c 20 Mar 2003 02:13:51 -0000 @@ -98,8 +98,9 @@ */ #include +#ifdef __NetBSD__ __KERNEL_RCSID(0, "$NetBSD: bktr_core.c,v 1.27 2003/01/10 01:38:52 mjl Exp $"); - +#endif #include "opt_bktr.h" /* Include any kernel config options */ @@ -112,10 +113,15 @@ __KERNEL_RCSID(0, "$NetBSD: bktr_core.c, #include #include #include +#if __FreeBSD_version >= 500000 #include +#else +#define SEL_WAITING(x) ((x)->si_pid) +#endif #include #include #include +#include #include #include @@ -474,8 +480,11 @@ static int i2c_read_byte(bktr_ptr_t void common_bktr_attach(bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev) { -#if defined(__NetBSD__) +#if defined(__NetBSD__) || defined(__OpenBSD__) vaddr_t buf = 0; +#elif defined(__FreeBSD__) + void *buf = NULL; + u_int32_t buf_addr = 0; #else vm_offset_t buf = 0; #endif @@ -510,16 +519,57 @@ common_bktr_attach(bktr_ptr_t bktr, int #if defined(BKTR_FREEBSD_MODULE) if (bktr_has_stored_addresses(unit) == 1) { /* recover the addresses */ +#ifdef __FreeBSD__ + bktr->dma_prog_addr = bktr_retrieve_address(unit, + BKTR_MEM_DMA_PROG, &bktr->dmat_prog, &bktr->dm_prog, + &bktr->dma_prog); + bktr->odd_dma_prog_addr = bktr_retrieve_address(unit, + BKTR_MEM_ODD_DMA_PROG, &bktr->dmat_prog, &bktr->dm_prog, + &bktr->odd_dma_prog); + bktr->vbidata_addr = bktr_retrieve_address(unit, + BKTR_MEM_VBIDATA, &bktr->dmat_vbidata, &bktr->dm_vbidata, + &bktr->vbidata); + bktr->vbibuffer_addr = bktr_retrieve_address(unit, + BKTR_MEM_VBIBUFFER, &bktr->dmat_vbibuffer, + &bktr->dm_vbibuffer, &bktr->vbibuffer); + buf_addr = bktr_retrieve_address(unit, + BKTR_MEM_BUF, &bktr->dmat_mem, &bktr->dm_mem, &buf); +#else bktr->dma_prog = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG); bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG); bktr->vbidata = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA); bktr->vbibuffer = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER); buf = bktr_retrieve_address(unit, BKTR_MEM_BUF); +#endif /* __FreeBSD__ */ need_to_allocate_memory = 0; } #endif if (need_to_allocate_memory == 1) { +#ifdef __FreeBSD__ + bktr->dma_prog_addr = get_bktr_mem(bktr, &bktr->dm_prog, + &bktr->dma_prog, DMA_PROG_ALLOC, &bktr->dmat_prog); + if (bktr->dma_prog_addr == 0) + bktr->dma_prog = NULL; + bktr->odd_dma_prog_addr = get_bktr_mem(bktr, &bktr->dm_oprog, + &bktr->odd_dma_prog, DMA_PROG_ALLOC, &bktr->dmat_oprog); + if (bktr->odd_dma_prog_addr == 0) + bktr->dma_prog = NULL; + bktr->vbidata_addr = get_bktr_mem(bktr, &bktr->dm_vbidata, + &bktr->vbidata, VBI_DATA_SIZE, &bktr->dmat_vbidata); + if (bktr->vbidata_addr == 0) + bktr->vbidata = NULL; + bktr->vbibuffer_addr = get_bktr_mem(bktr, &bktr->dm_vbibuffer, + &bktr->vbibuffer, VBI_BUFFER_SIZE, &bktr->dmat_vbibuffer); + if (bktr->vbibuffer_addr == 0) + bktr->vbibuffer = NULL; + if (BROOKTREE_ALLOC) + buf_addr = get_bktr_mem(bktr, &bktr->dm_mem, &buf, + BROOKTREE_ALLOC, &bktr->dmat_mem); + else + buf_addr = 0; + +#else /* allocate space for dma program */ bktr->dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC); bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC); @@ -533,28 +583,50 @@ common_bktr_attach(bktr_ptr_t bktr, int buf = get_bktr_mem(unit, BROOKTREE_ALLOC); else buf = 0; +#endif /* __FreeBSD__ */ } #endif /* FreeBSD or BSDi */ /* If this is a module, save the current contiguous memory */ #if defined(BKTR_FREEBSD_MODULE) +#ifdef __FreeBSD__ +bktr_store_address(unit, BKTR_MEM_DMA_PROG, bktr->dma_prog_addr, + bktr->dmat_prog, bktr->dm_prog, bktr->dma_prog); +bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog_addr, + bktr->dmat_oprog, bktr->dm_prog, bktr->odd_dma_prog); +bktr_store_address(unit, BKTR_MEM_VBIDATA, bktr->vbidata_addr, + bktr->dmat_vbidata, bktr->dm_vbidata, bktr->vbidata); +bktr_store_address(unit, BKTR_MEM_VBIBUFFER, bktr->vbibuffer_addr, + bktr->dmat_vbibuffer, bktr->dm_vbidata, bktr->vbibuffer); +bktr_store_address(unit, BKTR_MEM_BUF, buf_addr, bktr->dmat_mem, + bktr->dm_mem, buf); +#else bktr_store_address(unit, BKTR_MEM_DMA_PROG, bktr->dma_prog); bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog); bktr_store_address(unit, BKTR_MEM_VBIDATA, bktr->vbidata); bktr_store_address(unit, BKTR_MEM_VBIBUFFER, bktr->vbibuffer); bktr_store_address(unit, BKTR_MEM_BUF, buf); +#endif /* __FreeBSD__ */ #endif if (bootverbose) { printf("%s: buffer size %d, addr %p\n", bktr_name(bktr), BROOKTREE_ALLOC, - (void *)(uintptr_t)vtophys(buf)); +#ifdef __FreeBSD__ + (void *)buf_addr); +#else + (void *)DMA_PROG_ADDR(bktr)); +#endif } if (buf != 0) { + bktr->bigbuf = buf; +#ifdef __FreeBSD__ + bktr->bigbuf_addr = buf_addr; +#endif /* __FreeBSD__ */ bktr->alloc_pages = BROOKTREE_ALLOC_PAGES; bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC); } else { @@ -758,7 +830,7 @@ common_bktr_intr(void *arg) } } - OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); + OUTL(bktr, BKTR_RISC_STRT_ADD, DMA_PROG_ADDR(bktr)); OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); @@ -911,7 +983,6 @@ common_bktr_intr(void *arg) bktr->signal&(~METEOR_SIG_MODE_MASK)); PROC_UNLOCK(bktr->proc); } - /* * Reset the want flags if in continuous or * synchronous capture mode. @@ -1276,7 +1347,7 @@ vbi_read(bktr_ptr_t bktr, struct uio *ui /* * video ioctls */ -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) && __FreeBSD_version >= 500000 int video_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td) #else @@ -1292,8 +1363,11 @@ video_ioctl(bktr_ptr_t bktr, int unit, i struct meteor_counts *counts; struct meteor_video *video; struct bktr_capture_area *cap_area; -#if defined(__NetBSD__) +#if defined(__NetBSD__) || defined(__OpenBSD__) vaddr_t buf; +#elif defined(__FreeBSD__) + void *buf; + u_int32_t buf_addr; #else vm_offset_t buf; #endif @@ -1574,7 +1648,7 @@ video_ioctl(bktr_ptr_t bktr, int unit, i break; } bktr->signal = *(int *) arg; -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) && __FreeBSD_version >= 500000 bktr->proc = td->td_proc; #else bktr->proc = pr; @@ -1763,7 +1837,19 @@ video_ioctl(bktr_ptr_t bktr, int unit, i bktr->bigbuf); bktr->dm_mem = dmamap; -#else +#elif defined(__FreeBSD__) + bus_dmamap_t dmamap; + bus_dma_tag_t tmp_tag; + + buf_addr = get_bktr_mem(bktr, &dmamap, + &buf, temp * PAGE_SIZE, &tmp_tag); + if (buf_addr != 0) { + free_bktr_mem(bktr, bktr->dm_mem, + bktr->bigbuf, bktr->dmat_mem); + bktr->dm_mem = dmamap; + bktr->bigbuf_addr = buf_addr; + bktr->dmat_mem = tmp_tag; +#else buf = get_bktr_mem(unit, temp*PAGE_SIZE); if (buf != 0) { kmem_free(kernel_map, bktr->bigbuf, @@ -1898,7 +1984,7 @@ video_ioctl(bktr_ptr_t bktr, int unit, i /* * tuner ioctls */ -#ifdef __FreeBSD__ +#if defined(__FreeBSD__) && __FreeBSD_version >= 500000 int tuner_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td) #else @@ -2780,7 +2866,7 @@ rgb_vbi_prog(bktr_ptr_t bktr, char i_fla pitch = bktr->video.width; } else { - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long)BUF_ADDR(bktr); pitch = cols*Bpp; } @@ -2792,16 +2878,16 @@ rgb_vbi_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC | BKTR_VRE); *dma_prog++ = htole32(0); - loop_point = dma_prog; - + loop_point = (u_long *) DMA_PROG_ADDR(bktr) + + ((u_long) dma_prog - (u_long) bktr->dma_prog); /* store the VBI data */ /* look for sync with packed data */ *dma_prog++ = htole32(OP_SYNC | BKTR_FM1); *dma_prog++ = htole32(0); for(i = 0; i < vbilines; i++) { *dma_prog++ = htole32(OP_WRITE | OP_SOL | OP_EOL | vbisamples); - *dma_prog++ = htole32((u_long) vtophys(bktr->vbidata + - (i * VBI_LINE_SIZE))); + *dma_prog++ = htole32((u_long)VBIDATA_ADDR(bktr) + + (i * VBI_LINE_SIZE)); } if ((i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/) { @@ -2822,7 +2908,7 @@ rgb_vbi_prog(bktr_ptr_t bktr, char i_fla if (bktr->y != bktr->y2) { split(bktr, (volatile u_long **) &dma_prog, bktr->y2 - bktr->y, OP_WRITE, - Bpp, (volatile u_char **) &target, cols); + Bpp, (volatile u_char **)(uintptr_t) &target, cols); } if (bktr->yclip != bktr->yclip2) { split(bktr,(volatile u_long **) &dma_prog, @@ -2851,8 +2937,8 @@ rgb_vbi_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(0); for(i = 0; i < vbilines; i++) { *dma_prog++ = htole32(OP_WRITE | OP_SOL | OP_EOL | vbisamples); - *dma_prog++ = htole32((u_long) vtophys(bktr->vbidata + - ((i+MAX_VBI_LINES) * VBI_LINE_SIZE))); + *dma_prog++ = htole32((u_long) VBIDATA_ADDR(bktr) + + ((i+MAX_VBI_LINES) * VBI_LINE_SIZE)); } /* store the video image */ @@ -2901,7 +2987,7 @@ rgb_vbi_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys((vaddr_t)loop_point)); + *dma_prog++ = htole32((u_long) loop_point); *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -2952,7 +3038,7 @@ rgb_prog(bktr_ptr_t bktr, char i_flag, i pitch = bktr->video.width; } else { - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); pitch = cols*Bpp; } @@ -2999,7 +3085,7 @@ rgb_prog(bktr_ptr_t bktr, char i_flag, i *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 2: @@ -3008,7 +3094,7 @@ rgb_prog(bktr_ptr_t bktr, char i_flag, i *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 3: @@ -3016,7 +3102,7 @@ rgb_prog(bktr_ptr_t bktr, char i_flag, i *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->odd_dma_prog)); + *dma_prog++ = htole32((u_long) ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3063,7 +3149,7 @@ rgb_prog(bktr_ptr_t bktr, char i_flag, i *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3106,7 +3192,7 @@ yuvpack_prog(bktr_ptr_t bktr, char i_fla if (bktr->video.addr) target_buffer = (u_long) bktr->video.addr; else - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); buffer = target_buffer; @@ -3132,7 +3218,7 @@ yuvpack_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 2: @@ -3140,7 +3226,7 @@ yuvpack_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 3: @@ -3148,7 +3234,7 @@ yuvpack_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->odd_dma_prog)); + *dma_prog++ = htole32((u_long) ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3175,10 +3261,10 @@ yuvpack_prog(bktr_ptr_t bktr, char i_fla *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3224,7 +3310,7 @@ yuv422_prog(bktr_ptr_t bktr, char i_flag if (bktr->video.addr) target_buffer = (u_long) bktr->video.addr; else - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); buffer = target_buffer; @@ -3249,7 +3335,7 @@ yuv422_prog(bktr_ptr_t bktr, char i_flag *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 2: @@ -3257,7 +3343,7 @@ yuv422_prog(bktr_ptr_t bktr, char i_flag *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 3: @@ -3265,7 +3351,7 @@ yuv422_prog(bktr_ptr_t bktr, char i_flag *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->odd_dma_prog)); + *dma_prog++ = htole32((u_long) ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3291,7 +3377,7 @@ yuv422_prog(bktr_ptr_t bktr, char i_flag *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3325,7 +3411,7 @@ yuv12_prog(bktr_ptr_t bktr, char i_flag, if (bktr->video.addr) target_buffer = (u_long) bktr->video.addr; else - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); buffer = target_buffer; t1 = buffer; @@ -3353,7 +3439,7 @@ yuv12_prog(bktr_ptr_t bktr, char i_flag, *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 2: @@ -3361,14 +3447,14 @@ yuv12_prog(bktr_ptr_t bktr, char i_flag, *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); return; case 3: *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->odd_dma_prog)); + *dma_prog++ = htole32((u_long) ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3401,7 +3487,7 @@ yuv12_prog(bktr_ptr_t bktr, char i_flag, *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE); *dma_prog++ = htole32(0); /* NULL WORD */ *dma_prog++ = htole32(OP_JUMP); - *dma_prog++ = htole32((u_long) vtophys(bktr->dma_prog)); + *dma_prog++ = htole32((u_long) DMA_PROG_ADDR(bktr)); *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3561,7 +3647,7 @@ build_dma_prog(bktr_ptr_t bktr, char i_f break; } - OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); + OUTL(bktr, BKTR_RISC_STRT_ADD, DMA_PROG_ADDR(bktr)); rows = bktr->rows; cols = bktr->cols; @@ -3669,7 +3755,7 @@ start_capture(bktr_ptr_t bktr, unsigned } - OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); + OUTL(bktr, BKTR_RISC_STRT_ADD, DMA_PROG_ADDR(bktr)); } Index: bktr_core.h =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_core.h,v retrieving revision 1.3 diff -u -p -r1.3 bktr_core.h --- bktr_core.h 11 Mar 2003 23:11:23 -0000 1.3 +++ bktr_core.h 20 Mar 2003 02:13:51 -0000 @@ -84,14 +84,21 @@ int common_bktr_intr(void *arg); int video_open(bktr_ptr_t bktr); int video_close(bktr_ptr_t bktr); int video_read(bktr_ptr_t bktr, int unit, dev_t dev, struct uio *uio); -int video_ioctl(bktr_ptr_t bktr, int unit, - ioctl_cmd_t cmd, caddr_t arg, struct proc* pr); - +int video_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, +#if defined(__FreeBSD__) && __FreeBSD_version > 500000 + struct thread *pr); +#else + struct proc* pr); +#endif int tuner_open(bktr_ptr_t bktr); int tuner_close(bktr_ptr_t bktr); -int tuner_ioctl(bktr_ptr_t bktr, int unit, - ioctl_cmd_t cmd, caddr_t arg, struct proc* pr); +int tuner_ioctl(bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, +#if defined(__FreeBSD__) && __FreeBSD_version > 500000 + struct thread *pr); +#else + struct proc* pr); +#endif int vbi_open(bktr_ptr_t bktr); int vbi_close(bktr_ptr_t bktr); Index: bktr_mem.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_mem.c,v retrieving revision 1.3 diff -u -p -r1.3 bktr_mem.c --- bktr_mem.c 11 Mar 2003 23:11:25 -0000 1.3 +++ bktr_mem.c 20 Mar 2003 02:13:53 -0000 @@ -1,7 +1,4 @@ -/* $Id: bktr_mem.c,v 1.3 2003/03/11 23:11:25 thomasklausner Exp $ */ - -/* $NetBSD: bktr_mem.c,v 1.2 2001/11/13 07:29:37 lukem Exp $ */ -/* $FreeBSD: src/sys/dev/bktr/bktr_mem.c,v 1.4 2000/09/11 12:23:50 roger Exp$ */ +/* $FreeBSD: src/sys/dev/bktr/bktr_mem.c,v 1.6 2001/11/26 04:06:47 rwatson Exp $ */ /* * This is prt of the Driver for Video Capture Cards (Frame grabbers) @@ -48,22 +45,36 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#include -__KERNEL_RCSID(0, "$NetBSD: bktr_mem.c,v 1.2 2001/11/13 07:29:37 lukem Exp $"); - #include #include -#include -#include +#include + +#include + #include struct memory_pointers { int addresses_stored; - vm_offset_t dma_prog; - vm_offset_t odd_dma_prog; - vm_offset_t vbidata; - vm_offset_t vbibuffer; - vm_offset_t buf; + u_int32_t dma_prog_addr; + u_int32_t odd_dma_prog_addr; + u_int32_t vbidata_addr; + u_int32_t vbibuffer_addr; + u_int32_t buf_addr; + void *dma_prog; + void *odd_dma_prog; + void *vbidata; + void *vbibuffer; + void *buf; + bus_dma_tag_t dmat_prog; + bus_dmamap_t dm_prog; + bus_dma_tag_t dmat_oprog; + bus_dmamap_t dm_oprog; + bus_dma_tag_t dmat_mem; + bus_dmamap_t dm_mem; + bus_dma_tag_t dmat_vbidata; + bus_dmamap_t dm_vbidata; + bus_dma_tag_t dmat_vbibuffer; + bus_dmamap_t dm_vbibuffer; } memory_pointers; static struct memory_pointers memory_list[BKTR_MEM_MAX_DEVICES]; @@ -71,7 +82,7 @@ static struct memory_pointers memory_lis /*************************************************************/ static int -bktr_mem_modevent(module_t mod, int type, void *unused) { +bktr_mem_modevent(module_t mod, int type, void *unused){ switch (type) { case MOD_LOAD: @@ -117,7 +128,9 @@ bktr_has_stored_addresses(int unit) { /*************************************************************/ void -bktr_store_address(int unit, int type, vm_offset_t addr) { +bktr_store_address(int unit, int type, u_int32_t addr, bus_dma_tag_t tag, + bus_dmamap_t dmamap, void *buf) +{ if ((unit < 0) || (unit >= BKTR_MEM_MAX_DEVICES)) { printf("bktr_mem: Unit number %d invalid for memory type %d, address 0x%x\n" @@ -126,20 +139,35 @@ bktr_store_address(int unit, int type, v } switch (type) { - case BKTR_MEM_DMA_PROG: memory_list[unit].dma_prog = addr; + case BKTR_MEM_DMA_PROG: memory_list[unit].dma_prog_addr = addr; memory_list[unit].addresses_stored = 1; + memory_list[unit].dma_prog = buf; + memory_list[unit].dmat_prog = tag; + memory_list[unit].dm_prog = dmamap; break; - case BKTR_MEM_ODD_DMA_PROG: memory_list[unit].odd_dma_prog = addr; + case BKTR_MEM_ODD_DMA_PROG: memory_list[unit].odd_dma_prog_addr = addr; memory_list[unit].addresses_stored = 1; + memory_list[unit].odd_dma_prog = buf; + memory_list[unit].dmat_oprog = tag; + memory_list[unit].dm_oprog = dmamap; break; - case BKTR_MEM_VBIDATA: memory_list[unit].vbidata = addr; + case BKTR_MEM_VBIDATA: memory_list[unit].vbidata_addr = addr; memory_list[unit].addresses_stored = 1; + memory_list[unit].vbidata = buf; + memory_list[unit].dm_vbidata = dmamap; + memory_list[unit].dmat_vbidata = tag; break; - case BKTR_MEM_VBIBUFFER: memory_list[unit].vbibuffer = addr; + case BKTR_MEM_VBIBUFFER: memory_list[unit].vbibuffer_addr = addr; memory_list[unit].addresses_stored = 1; + memory_list[unit].vbibuffer = buf; + memory_list[unit].dm_vbibuffer = dmamap; + memory_list[unit].dmat_vbibuffer = tag; break; - case BKTR_MEM_BUF: memory_list[unit].buf = addr; + case BKTR_MEM_BUF: memory_list[unit].buf_addr = addr; memory_list[unit].addresses_stored = 1; + memory_list[unit].buf = buf; + memory_list[unit].dm_mem = dmamap; + memory_list[unit].dmat_mem = tag; break; default: printf("bktr_mem: Invalid memory type %d for bktr%d, address 0x%xn", type,unit,addr); @@ -149,19 +177,41 @@ bktr_store_address(int unit, int type, v /*************************************************************/ -vm_offset_t -bktr_retrieve_address(int unit, int type) { +u_int32_t +bktr_retrieve_address(int unit, int type, bus_dma_tag_t *tag, + bus_dmamap_t *dmamap, void **buf) +{ if ((unit < 0) || (unit >= BKTR_MEM_MAX_DEVICES)) { printf("bktr_mem: Unit number %d too large for memory type %d\n",unit,type); return NULL; } switch (type) { - case BKTR_MEM_DMA_PROG: return memory_list[unit].dma_prog; - case BKTR_MEM_ODD_DMA_PROG: return memory_list[unit].odd_dma_prog; - case BKTR_MEM_VBIDATA: return memory_list[unit].vbidata; - case BKTR_MEM_VBIBUFFER: return memory_list[unit].vbibuffer; - case BKTR_MEM_BUF: return memory_list[unit].buf; + case BKTR_MEM_DMA_PROG: + *tag = memory_list[unit].dmat_prog; + *dmamap = memory_list[unit].dm_prog; + *buf = memory_list[unit].dma_prog; + return memory_list[unit].dma_prog_addr; + case BKTR_MEM_ODD_DMA_PROG: + *tag = memory_list[unit].dmat_oprog; + *dmamap = memory_list[unit].dm_oprog; + *buf = memory_list[unit].odd_dma_prog; + return memory_list[unit].odd_dma_prog_addr; + case BKTR_MEM_VBIDATA: + *tag = memory_list[unit].dmat_vbidata; + *dmamap = memory_list[unit].dm_vbidata; + *buf = memory_list[unit].vbidata; + return memory_list[unit].vbidata_addr; + case BKTR_MEM_VBIBUFFER: + *tag = memory_list[unit].dmat_vbibuffer; + *dmamap = memory_list[unit].dm_vbibuffer; + *buf = memory_list[unit].vbibuffer; + return memory_list[unit].vbibuffer_addr; + case BKTR_MEM_BUF: + *tag = memory_list[unit].dmat_mem; + *dmamap = memory_list[unit].dm_mem; + *buf = memory_list[unit].buf; + return memory_list[unit].buf_addr; default: printf("bktr_mem: Invalid memory type %d for bktr%d",type,unit); return NULL; } Index: bktr_mem.h =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_mem.h,v retrieving revision 1.2 diff -u -p -r1.2 bktr_mem.h --- bktr_mem.h 11 Mar 2003 23:11:25 -0000 1.2 +++ bktr_mem.h 20 Mar 2003 02:13:53 -0000 @@ -1,7 +1,4 @@ -/* $Id: bktr_mem.h,v 1.2 2003/03/11 23:11:25 thomasklausner Exp $ */ - -/* $NetBSD: bktr_mem.h,v 1.1 2000/10/28 14:17:41 wiz Exp $ */ -/* $FreeBSD: src/sys/dev/bktr/bktr_mem.h,v 1.1 2000/09/10 14:34:08 roger Exp$ */ +/* $FreeBSD: src/sys/dev/bktr/bktr_mem.h,v 1.1 2000/09/10 14:34:08 roger Exp $ */ /* * This is prt of the Driver for Video Capture Cards (Frame grabbers) @@ -61,6 +58,7 @@ /* Prototypes */ int bktr_has_stored_addresses(int unit); -void bktr_store_address(int unit, int type, vm_offset_t addr); -vm_offset_t bktr_retrieve_address(int unit, int type); - +void bktr_store_address(int unit, int type, u_int32_t addr, + bus_dma_tag_t tag, bus_dmamap_t dmamap, void *buf); +u_int32_t bktr_retrieve_address(int unit, int type, bus_dma_tag_t *tag, + bus_dmamap_t *dmamap, void **buf); Index: bktr_os.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_os.c,v retrieving revision 1.5 diff -u -p -r1.5 bktr_os.c --- bktr_os.c 11 Mar 2003 23:11:25 -0000 1.5 +++ bktr_os.c 20 Mar 2003 02:13:56 -0000 @@ -51,11 +51,9 @@ */ #include +#ifdef __NetBSD__ __KERNEL_RCSID(0, "$NetBSD: bktr_os.c,v 1.34 2003/01/10 01:38:53 mjl Exp $"); - -#ifdef __FreeBSD__ -#include "bktr.h" -#endif /* __FreeBSD__ */ +#endif #include "opt_bktr.h" /* include any kernel config options */ @@ -83,7 +81,7 @@ __KERNEL_RCSID(0, "$NetBSD: bktr_os.c,v #include #include -#if (__FreeBSD_version >=400000) || (NSMBUS > 0) +#if (__FreeBSD_version >=400000) #include /* used by smbus and newbus */ #endif @@ -119,9 +117,6 @@ SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_ SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, ""); SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, ""); -#if (__FreeBSD__ == 2) -#define PCIR_REVID PCI_CLASS_REG -#endif #endif /* end freebsd section */ @@ -239,6 +234,21 @@ static device_method_t bktr_methods[] = { 0, 0 } }; +#if defined(BKTR_USE_FREEBSD_SMBUS) + /* iicbb interface */ + DEVMETHOD(iicbb_callback, bti2c_iic_callback), + DEVMETHOD(iicbb_setsda, bti2c_iic_setsda), + DEVMETHOD(iicbb_setscl, bti2c_iic_setscl), + DEVMETHOD(iicbb_getsda, bti2c_iic_getsda), + DEVMETHOD(iicbb_getscl, bti2c_iic_getscl), + DEVMETHOD(iicbb_reset, bti2c_iic_reset), + + /* smbus interface */ + DEVMETHOD(smbus_callback, bti2c_smb_callback), + DEVMETHOD(smbus_writeb, bti2c_smb_writeb), + DEVMETHOD(smbus_writew, bti2c_smb_writew), + DEVMETHOD(smbus_readb, bti2c_smb_readb), +#endif static driver_t bktr_driver = { "bktr", bktr_methods, @@ -257,22 +267,16 @@ static d_poll_t bktr_poll; #define CDEV_MAJOR 92 static struct cdevsw bktr_cdevsw = { - /* open */ bktr_open, - /* close */ bktr_close, - /* read */ bktr_read, - /* write */ bktr_write, - /* ioctl */ bktr_ioctl, - /* poll */ bktr_poll, - /* mmap */ bktr_mmap, - /* strategy */ nostrategy, - /* name */ "bktr", - /* maj */ CDEV_MAJOR, - /* dump */ nodump, - /* psize */ nopsize, - /* flags */ 0, - /* bmaj */ -1 + .d_open = bktr_open, + .d_close = bktr_close, + .d_read = bktr_read, + .d_write = bktr_write, + .d_ioctl = bktr_ioctl, + .d_poll = bktr_poll, + .d_mmap = bktr_mmap, + .d_name = "bktr", + .d_maj = CDEV_MAJOR, }; - DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0); #if (__FreeBSD_version > 410000) MODULE_DEPEND(bktr, bktr_mem, 1,1,1); @@ -417,7 +421,7 @@ bktr_attach(device_t dev) /* XXX call bt848_i2c dependent attach() routine */ #if defined(BKTR_USE_FREEBSD_SMBUS) - if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc)) + if (bt848_i2c_attach(dev)) printf("bktr%d: i2c_attach: can't attach\n", unit); #endif @@ -499,6 +503,11 @@ bktr_detach(device_t dev) OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); +#if defined(BKTR_USE_FREEBSD_SMBUS) + if (bt848_i2c_detach(dev)) + printf("bktr%d: i2c_attach: can't attach\n", unit); +#endif + /* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */ /* The memory is retained by the bktr_mem module so we can unload and */ /* then reload the main bktr driver module */ @@ -546,20 +555,55 @@ bktr_shutdown(device_t dev) /* * Special Memory Allocation */ -vm_offset_t -get_bktr_mem(int unit, unsigned size) + +static void +bktr_getaddr(void *arg, bus_dma_segment_t *segs, int nseg, int error) +{ + u_int32_t *addr = (u_int32_t *)arg; + + if (error) + return; + *addr = segs->ds_addr; +} + +u_int32_t +get_bktr_mem(bktr_ptr_t bktr, bus_dmamap_t *dmamap, void **buf, unsigned size, + bus_dma_tag_t *dmat) { - vm_offset_t addr = 0; + u_int32_t addr; - addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24); - if (addr == 0) - addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE); - if (addr == 0) { - printf("bktr%d: Unable to allocate %d bytes of memory.\n", - unit, size); + if (bus_dma_tag_create(NULL, PAGE_SIZE, 0, BUS_SPACE_MAXADDR, + BUS_SPACE_MAXADDR, NULL, NULL, size, 1, + BUS_SPACE_MAXSIZE_32BIT, 0, dmat) + != 0) { + printf("%s: couldn't create tag\n", bktr_name(bktr)); + return (0); + } + if (bus_dmamem_alloc(*dmat, buf, BUS_DMA_NOWAIT, dmamap) != 0) { + printf("%s: couldn't allocate %d bytes\n", bktr_name(bktr), + size); + bus_dma_tag_destroy(*dmat); + return(0); + } + if (bus_dmamap_load(*dmat, *dmamap, *buf, size, bktr_getaddr, &addr, 0) + != 0) { + printf("%s: bus_dmamap_load failed\n", bktr_name(bktr)); + bus_dmamem_free(*dmat, *buf, *dmamap); + bus_dma_tag_destroy(*dmat); + return (0); } + return (addr); +} - return(addr); +void +free_bktr_mem(bktr_ptr_t bktr, bus_dmamap_t dmamap, void *buf, + bus_dma_tag_t dmat) +{ + + bus_dmamap_unload(dmat, dmamap); + bus_dmamem_free(dmat, buf, dmamap); + bus_dmamap_destroy(dmat, dmamap); + bus_dma_tag_destroy(dmat); } @@ -581,7 +625,12 @@ get_bktr_mem(int unit, unsigned size) * */ int -bktr_open(dev_t dev, int flags, int fmt, struct proc *p) +bktr_open(dev_t dev, int flags, int fmt, +#if __FreeBSD_version >= 500000 + struct thread *td) +#else + struct proc *p) +#endif { bktr_ptr_t bktr; int unit; @@ -661,7 +710,12 @@ bktr_open(dev_t dev, int flags, int fmt, * */ int -bktr_close(dev_t dev, int flags, int fmt, struct proc *p) +bktr_close(dev_t dev, int flags, int fmt, +#if __FreeBSD_version >= 500000 + struct thread *td) +#else + struct proc *p) +#endif { bktr_ptr_t bktr; int unit; @@ -738,7 +792,12 @@ bktr_write(dev_t dev, struct uio *uio, i * */ int -bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr) +bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, +#if __FreeBSD_version >= 500000 + struct thread *pr) +#else + struct proc* pr) +#endif { bktr_ptr_t bktr; int unit; @@ -770,7 +829,11 @@ bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, c * */ int +#if __FreeBSD_version >= 500000 +bktr_mmap(dev_t dev, vm_offset_t offset, vm_offset_t *paddr, int nprot) +#else bktr_mmap(dev_t dev, vm_offset_t offset, int nprot) +#endif { int unit; bktr_ptr_t bktr; @@ -796,10 +859,20 @@ bktr_mmap(dev_t dev, vm_offset_t offset, if (offset >= bktr->alloc_pages * PAGE_SIZE) return(-1); - return(atop(vtophys(bktr->bigbuf) + offset)); +#if __FreeBSD_version >= 500000 + *paddr = vtophys(bktr->bigbuf) + offset; + return (0); +#else + return (atop(vtophys(bktr->bigbuf) + offset)); +#endif } -int bktr_poll(dev_t dev, int events, struct proc *p) +int bktr_poll(dev_t dev, int events, +#if __FreeBSD_version >= 500000 + struct thread *p) +#else + struct proc *p) +#endif { int unit; bktr_ptr_t bktr; @@ -836,469 +909,6 @@ int bktr_poll(dev_t dev, int events, str #endif /* FreeBSD 4.x specific kernel interface routines */ -/**********************************/ -/* *** FreeBSD 2.2.x and 3.x *** */ -/**********************************/ - -#if ((__FreeBSD__ == 2) || (__FreeBSD__ == 3)) - -static bktr_reg_t brooktree[NBKTR]; - -static const char* bktr_probe(pcici_t tag, pcidi_t type); -static void bktr_attach(pcici_t tag, int unit); -static void bktr_intr(void *arg) { common_bktr_intr(arg); } - -static u_long bktr_count; - -static struct pci_device bktr_device = { - "bktr", - bktr_probe, - bktr_attach, - &bktr_count -}; - -DATA_SET (pcidevice_set, bktr_device); - -static d_open_t bktr_open; -static d_close_t bktr_close; -static d_read_t bktr_read; -static d_write_t bktr_write; -static d_ioctl_t bktr_ioctl; -static d_mmap_t bktr_mmap; -static d_poll_t bktr_poll; - -#define CDEV_MAJOR 92 -static struct cdevsw bktr_cdevsw = -{ - bktr_open, bktr_close, bktr_read, bktr_write, - bktr_ioctl, nostop, nullreset, nodevtotty, - bktr_poll, bktr_mmap, NULL, "bktr", - NULL, -1 -}; - -static int bktr_devsw_installed; - -static void -bktr_drvinit(void *unused) -{ - dev_t dev; - - if (! bktr_devsw_installed) { - dev = makedev(CDEV_MAJOR, 0); - cdevsw_add(&dev,&bktr_cdevsw, NULL); - bktr_devsw_installed = 1; - } -} - -SYSINIT(bktrdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bktr_drvinit,NULL) - -/* - * the boot time probe routine. - */ -static const char* -bktr_probe(pcici_t tag, pcidi_t type) -{ - unsigned int rev = pci_conf_read(tag, PCIR_REVID) & 0x000000ff; - - if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE) - { - switch (PCI_PRODUCT(type)) { - case PCI_PRODUCT_BROOKTREE_BT848: - if (rev == 0x12) return("BrookTree 848A"); - else return("BrookTree 848"); - case PCI_PRODUCT_BROOKTREE_BT849: - return("BrookTree 849A"); - case PCI_PRODUCT_BROOKTREE_BT878: - return("BrookTree 878"); - case PCI_PRODUCT_BROOKTREE_BT879: - return("BrookTree 879"); - } - }; - - return ((char *)0); -} - -/* - * the attach routine. - */ -static void -bktr_attach(pcici_t tag, int unit) -{ - bktr_ptr_t bktr; - u_long latency; - u_long fun; - unsigned int rev; - unsigned long base; -#ifdef BROOKTREE_IRQ - u_long old_irq, new_irq; -#endif - - bktr = &brooktree[unit]; - - if (unit >= NBKTR) { - printf("brooktree%d: attach: only %d units configured.\n", - unit, NBKTR); - printf("brooktree%d: attach: invalid unit number.\n", unit); - return; - } - - /* build the device name for bktr_name() */ - snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit); - - /* Enable Memory Mapping */ - fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG); - pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 2); - - /* Enable Bus Mastering */ - fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG); - pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 4); - - bktr->tag = tag; - - - /* - * Map control/status registers - */ - pci_map_mem(tag, PCI_MAP_REG_START, (vm_offset_t *) &base, - &bktr->phys_base); -#if (__FreeBSD_version >= 300000) - bktr->memt = I386_BUS_SPACE_MEM; /* XXX should use proper bus space */ - bktr->memh = (bus_space_handle_t)base; /* XXX functions here */ -#endif - - /* - * Disable the brooktree device - */ - OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); - OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); - -#ifdef BROOKTREE_IRQ /* from the configuration file */ - old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); - pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ); - new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); - printf("bktr%d: attach: irq changed from %d to %d\n", - unit, (old_irq & 0xff), (new_irq & 0xff)); -#endif - - /* - * setup the interrupt handling routine - */ - pci_map_int(tag, bktr_intr, (void*) bktr, &tty_imask); - - - /* Update the Device Control Register */ - /* on Bt878 and Bt879 cards */ - fun = pci_conf_read(tag, 0x40); - fun = fun | 1; /* Enable writes to the sub-system vendor ID */ - -#if defined(BKTR_430_FX_MODE) - if (bootverbose) printf("Using 430 FX chipset compatibility mode\n"); - fun = fun | 2; /* Enable Intel 430 FX compatibility mode */ -#endif - -#if defined(BKTR_SIS_VIA_MODE) - if (bootverbose) printf("Using SiS/VIA chipset compatibility mode\n"); - fun = fun | 4; /* Enable SiS/VIA compatibility mode (useful for - OPTi chipset motherboards too */ -#endif - pci_conf_write(tag, 0x40, fun); - - - /* XXX call bt848_i2c dependent attach() routine */ -#if defined(BKTR_USE_FREEBSD_SMBUS) - if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc)) - printf("bktr%d: i2c_attach: can't attach\n", unit); -#endif - - -/* - * PCI latency timer. 32 is a good value for 4 bus mastering slots, if - * you have more than four, then 16 would probably be a better value. - */ -#ifndef BROOKTREE_DEF_LATENCY_VALUE -#define BROOKTREE_DEF_LATENCY_VALUE 10 -#endif - latency = pci_conf_read(tag, PCI_LATENCY_TIMER); - latency = (latency >> 8) & 0xff; - if (bootverbose) { - if (latency) - printf("brooktree%d: PCI bus latency is", unit); - else - printf("brooktree%d: PCI bus latency was 0 changing to", - unit); - } - if (!latency) { - latency = BROOKTREE_DEF_LATENCY_VALUE; - pci_conf_write(tag, PCI_LATENCY_TIMER, latency<<8); - } - if (bootverbose) { - printf(" %d.\n", (int) latency); - } - - - /* read the pci device id and revision id */ - fun = pci_conf_read(tag, PCI_ID_REG); - rev = pci_conf_read(tag, PCIR_REVID) & 0x000000ff; - - /* call the common attach code */ - common_bktr_attach(bktr, unit, fun, rev); - -} - - -/* - * Special Memory Allocation - */ -vm_offset_t -get_bktr_mem(int unit, unsigned size) -{ - vm_offset_t addr = 0; - - addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, 1<<24); - if (addr == 0) - addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, - PAGE_SIZE); - if (addr == 0) { - printf("bktr%d: Unable to allocate %d bytes of memory.\n", - unit, size); - } - - return(addr); -} - -/*--------------------------------------------------------- -** -** BrookTree 848 character device driver routines -** -**--------------------------------------------------------- -*/ - - -#define VIDEO_DEV 0x00 -#define TUNER_DEV 0x01 -#define VBI_DEV 0x02 - -#define UNIT(x) ((x) & 0x0f) -#define FUNCTION(x) ((x >> 4) & 0x0f) - - -/* - * - */ -int -bktr_open(dev_t dev, int flags, int fmt, struct proc *p) -{ - bktr_ptr_t bktr; - int unit; - - unit = UNIT(minor(dev)); - if (unit >= NBKTR) /* unit out of range */ - return(ENXIO); - - bktr = &(brooktree[unit]); - - if (!(bktr->flags & METEOR_INITIALIZED)) /* device not found */ - return(ENXIO); - - - if (bt848_card != -1) { - if ((bt848_card >> 8 == unit) && - ((bt848_card & 0xff) < Bt848_MAX_CARD)) { - if (bktr->bt848_card != (bt848_card & 0xff)) { - bktr->bt848_card = (bt848_card & 0xff); - probeCard(bktr, FALSE, unit); - } - } - } - - if (bt848_tuner != -1) { - if ((bt848_tuner >> 8 == unit) && - ((bt848_tuner & 0xff) < Bt848_MAX_TUNER)) { - if (bktr->bt848_tuner != (bt848_tuner & 0xff)) { - bktr->bt848_tuner = (bt848_tuner & 0xff); - probeCard(bktr, FALSE, unit); - } - } - } - - if (bt848_reverse_mute != -1) { - if ((bt848_reverse_mute >> 8) == unit) { - bktr->reverse_mute = bt848_reverse_mute & 0xff; - } - } - - if (bt848_slow_msp_audio != -1) { - if ((bt848_slow_msp_audio >> 8) == unit) { - bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff); - } - } - - switch (FUNCTION(minor(dev))) { - case VIDEO_DEV: - return(video_open(bktr)); - case TUNER_DEV: - return(tuner_open(bktr)); - case VBI_DEV: - return(vbi_open(bktr)); - } - return(ENXIO); -} - - -/* - * - */ -int -bktr_close(dev_t dev, int flags, int fmt, struct proc *p) -{ - bktr_ptr_t bktr; - int unit; - - unit = UNIT(minor(dev)); - if (unit >= NBKTR) /* unit out of range */ - return(ENXIO); - - bktr = &(brooktree[unit]); - - switch (FUNCTION(minor(dev))) { - case VIDEO_DEV: - return(video_close(bktr)); - case TUNER_DEV: - return(tuner_close(bktr)); - case VBI_DEV: - return(vbi_close(bktr)); - } - - return(ENXIO); -} - -/* - * - */ -int -bktr_read(dev_t dev, struct uio *uio, int ioflag) -{ - bktr_ptr_t bktr; - int unit; - - unit = UNIT(minor(dev)); - if (unit >= NBKTR) /* unit out of range */ - return(ENXIO); - - bktr = &(brooktree[unit]); - - switch (FUNCTION(minor(dev))) { - case VIDEO_DEV: - return(video_read(bktr, unit, dev, uio)); - case VBI_DEV: - return(vbi_read(bktr, uio, ioflag)); - } - return(ENXIO); -} - - -/* - * - */ -int -bktr_write(dev_t dev, struct uio *uio, int ioflag) -{ - return(EINVAL); /* XXX or ENXIO ? */ -} - -/* - * - */ -int -bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr) -{ - bktr_ptr_t bktr; - int unit; - - unit = UNIT(minor(dev)); - if (unit >= NBKTR) /* unit out of range */ - return(ENXIO); - - bktr = &(brooktree[unit]); - - if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */ - return(ENOMEM); - - switch (FUNCTION(minor(dev))) { - case VIDEO_DEV: - return(video_ioctl(bktr, unit, cmd, arg, pr)); - case TUNER_DEV: - return(tuner_ioctl(bktr, unit, cmd, arg, pr)); - } - - return(ENXIO); -} - -/* - * bktr_mmap. - * Note: 2.2.5/2.2.6/2.2.7/3.0 users must manually - * edit the line below and change "vm_offset_t" to "int" - */ -int bktr_mmap(dev_t dev, vm_offset_t offset, int nprot) - -{ - int unit; - bktr_ptr_t bktr; - - unit = UNIT(minor(dev)); - - if (unit >= NBKTR || FUNCTION(minor(dev)) > 0) - return(-1); - - bktr = &(brooktree[unit]); - - if (nprot & PROT_EXEC) - return(-1); - - if (offset < 0) - return(-1); - - if (offset >= bktr->alloc_pages * PAGE_SIZE) - return(-1); - - return(i386_btop(vtophys(bktr->bigbuf) + offset)); -} - -int bktr_poll(dev_t dev, int events, struct proc *p) -{ - int unit; - bktr_ptr_t bktr; - int revents = 0; - - unit = UNIT(minor(dev)); - - if (unit >= NBKTR) - return(-1); - - bktr = &(brooktree[unit]); - - disable_intr(); - - if (events & (POLLIN | POLLRDNORM)) { - - switch (FUNCTION(minor(dev))) { - case VBI_DEV: - if(bktr->vbisize == 0) - selrecord(p, &bktr->vbi_select); - else - revents |= events & (POLLIN | POLLRDNORM); - break; - } - } - - enable_intr(); - - return (revents); -} - - -#endif /* FreeBSD 2.2.x and 3.x specific kernel interface routines */ - /*****************/ /* *** BSDI *** */ @@ -1546,11 +1156,7 @@ bktr_attach(struct device *parent, struc /* * Special Memory Allocation */ -#if defined (__NetBSD__) vaddr_t -#else -vm_offset_t -#endif get_bktr_mem(bktr, dmapp, size) bktr_ptr_t bktr; bus_dmamap_t *dmapp; @@ -1604,11 +1210,7 @@ get_bktr_mem(bktr, dmapp, size) bus_dmamap_destroy(dmat, *dmapp); return 0; } -#if defined(__NetBSD__) return (vaddr_t)kva; -#else - return (vm_offset_t)kva; -#endif } void @@ -1857,7 +1459,7 @@ bktr_get_info(void *v, struct radio_info #endif /* __NetBSD__ || __OpenBSD__ */ -#if defined(__NetBSD__) +#if defined(__NetBSD__) || defined(__FreeBSD__) u_int8_t bktr_INB(struct bktr_softc *bktr, int offset) @@ -1910,4 +1512,4 @@ bktr_OUTL(struct bktr_softc *bktr, int o BUS_SPACE_BARRIER_WRITE); } -#endif /* __NetBSD__ */ +#endif /* __NetBSD__ || __FreeBSD__ */ Index: bktr_os.h =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_os.h,v retrieving revision 1.3 diff -u -p -r1.3 bktr_os.h --- bktr_os.h 11 Mar 2003 23:11:26 -0000 1.3 +++ bktr_os.h 20 Mar 2003 02:13:57 -0000 @@ -50,10 +50,16 @@ /******************************/ /* *** Memory Allocation *** */ /******************************/ -#if (defined(__FreeBSD__) || defined(__bsdi__)) +#if defined(__bsdi__) vm_offset_t get_bktr_mem(int unit, unsigned size); #endif +#if defined(__FreeBSD__) && (__FreeBSD_version >= 400000) +u_int32_t get_bktr_mem(bktr_ptr_t, bus_dmamap_t *, void **, + unsigned size, bus_dma_tag_t *); +void free_bktr_mem(bktr_ptr_t, bus_dmamap_t, void *, bus_dma_tag_t); +#endif + #if defined(__NetBSD__) vaddr_t get_bktr_mem(bktr_ptr_t, bus_dmamap_t *, unsigned size); void free_bktr_mem(bktr_ptr_t, bus_dmamap_t, vaddr_t); @@ -64,9 +70,36 @@ vm_offset_t get_bktr_mem(bktr_ptr_t, void free_bktr_mem(bktr_ptr_t, bus_dmamap_t, vm_offset_t); #endif +#ifdef __FreeBSD__ +#define BUF_ADDR(x) bktr->bigbuf_addr +#define DMA_PROG_ADDR(x) x->dma_prog_addr +#define ODD_DMA_PROG_ADDR(x) x->odd_dma_prog_addr +#define VBIDATA_ADDR(x) x->vbidata_addr +#define VBIBUFFER_ADDR(x) x->vbibuffer_addr +#else +#define BUF_ADDR(x) x->dm_mem->dm_segs->ds_addr +#define DMA_PROG_ADDR(x) x->dm_prog->dm_segs->ds_addr +#define ODD_DMA_PROG_ADDR(x) x->dm_oprog->dm_segs->ds_addr +#define VBIDATA_ADDR(x) x->dm_vbidata->dm_segs->ds_addr +#define VBIBUFFER_ADDR(x) +#endif + /************************************/ /* *** Interrupt Enable/Disable *** */ /************************************/ +#if defined(__FreeBSD__) +#if (__FreeBSD_version >= 500000) +#define DECLARE_INTR_MASK(s) /* no need to declare 's' */ +#define DISABLE_INTR(s) critical_enter() +#define ENABLE_INTR(s) critical_exit() +#else #define DECLARE_INTR_MASK(s) int s #define DISABLE_INTR(s) s = spltty() #define ENABLE_INTR(s) splx(s) +#endif /* __FreeBSD_version */ +#else +#define DECLARE_INTR_MASK(s) /* no need to declare 's' */ +#define DISABLE_INTR(s) disable_intr() +#define ENABLE_INTR(s) enable_intr() +#endif + Index: bktr_reg.h =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_reg.h,v retrieving revision 1.4 diff -u -p -r1.4 bktr_reg.h --- bktr_reg.h 13 Mar 2003 22:21:04 -0000 1.4 +++ bktr_reg.h 20 Mar 2003 02:13:59 -0000 @@ -37,17 +37,6 @@ * */ -#ifdef __FreeBSD__ -# if (__FreeBSD_version >= 310000) -# include "smbus.h" -# else -# define NSMBUS 0 /* FreeBSD before 3.1 does not have SMBUS */ -# endif -# if (NSMBUS > 0) -# define BKTR_USE_FREEBSD_SMBUS -# endif -#endif - #ifdef __NetBSD__ #include /* struct device */ #include @@ -471,7 +460,7 @@ struct bktr_i2c_softc { */ #if defined(__NetBSD__) || (defined(__FreeBSD__) && (__FreeBSD_version >=300000)) -#if defined(__NetBSD__) +#if defined(__NetBSD__) || defined(__FreeBSD__) struct bktr_softc; @@ -562,6 +551,16 @@ struct bktr_softc { pcici_t tag; /* 2.x PCI tag, for doing PCI commands */ #endif #if (__FreeBSD_version >= 400000) + bus_dma_tag_t dmat_prog; + bus_dmamap_t dm_prog; + bus_dma_tag_t dmat_oprog; + bus_dmamap_t dm_oprog; + bus_dma_tag_t dmat_mem; + bus_dmamap_t dm_mem; + bus_dma_tag_t dmat_vbidata; + bus_dmamap_t dm_vbidata; + bus_dma_tag_t dmat_vbibuffer; + bus_dmamap_t dm_vbibuffer; int mem_rid; /* 4.x resource id */ struct resource *res_mem; /* 4.x resource descriptor for registers */ int irq_rid; /* 4.x resource id */ @@ -579,7 +578,7 @@ struct bktr_softc { bus_space_handle_t memh; /* Bus space register access functions */ bus_size_t obmemsz;/* Size of card (bytes) */ #endif - #if (NSMBUS > 0) + #ifdef BKTR_USE_FREEBSD_SMBUS struct bktr_i2c_softc i2c_sc; /* bt848_i2c device */ #endif char bktr_xname[7]; /* device name and unit number */ @@ -587,12 +586,23 @@ struct bktr_softc { /* The following definitions are for the contiguous memory */ -#ifdef __NetBSD__ +#if defined(__NetBSD__) || defined(__OpenBSD__) vaddr_t bigbuf; /* buffer that holds the captured image */ vaddr_t vbidata; /* RISC program puts VBI data from the current frame here */ vaddr_t vbibuffer; /* Circular buffer holding VBI data for the user */ vaddr_t dma_prog; /* RISC prog for single and/or even field capture*/ vaddr_t odd_dma_prog; /* RISC program for Odd field capture */ +#elif defined(__FreeBSD__) + u_int32_t bigbuf_addr; + void *bigbuf; /* buffer that holds the captured image */ + u_int32_t vbidata_addr; + void *vbidata; /* RISC program puts VBI data from the current frame here */ + u_int32_t vbibuffer_addr; + void *vbibuffer; /* Circular buffer holding VBI data for the user */ + u_int32_t dma_prog_addr; + void *dma_prog; /* RISC prog for single and/or even field capture*/ + u_int32_t odd_dma_prog_addr; + void *odd_dma_prog; /* RISC program for Odd field capture */ #else vm_offset_t bigbuf; /* buffer that holds the captured image */ vm_offset_t vbidata; /* RISC program puts VBI data from the current frame here */ Index: bktr_tuner.c =================================================================== RCS file: /cvsroot/bktr/bktr/bktr_tuner.c,v retrieving revision 1.5 diff -u -p -r1.5 bktr_tuner.c --- bktr_tuner.c 13 Mar 2003 22:21:04 -0000 1.5 +++ bktr_tuner.c 20 Mar 2003 02:14:01 -0000 @@ -47,7 +47,9 @@ */ #include +#ifdef __NetBSD__ __KERNEL_RCSID(0, "$NetBSD: bktr_tuner.c,v 1.9 2001/11/13 07:29:37 lukem Exp $"); +#endif #include #include