Index: bktr_core.c =================================================================== RCS file: /space3/ncvs/src/sys/dev/bktr/bktr_core.c,v retrieving revision 1.124 diff -u -p -r1.124 bktr_core.c --- bktr_core.c 7 Dec 2002 09:00:19 -0000 1.124 +++ bktr_core.c 13 Feb 2003 04:06:51 -0000 @@ -117,6 +117,7 @@ #include #include #include +#include #include #include @@ -469,9 +470,13 @@ static int i2c_read_byte( bktr_ptr_ void common_bktr_attach( bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev ) { - vm_offset_t buf = 0; +#ifdef __FreeBSD__ + void *buf = NULL; + u_int32_t buf_addr = 0; int need_to_allocate_memory = 1; - +#else + vm_offset_t buf = 0; +#endif /***************************************/ /* *** OS Specific memory routines *** */ /***************************************/ @@ -495,57 +500,85 @@ common_bktr_attach( bktr_ptr_t bktr, int buf = 0; #endif -#if defined(__FreeBSD__) || defined(__bsdi__) - /* If this is a module, check if there is any currently saved contiguous memory */ +#ifdef __FreeBSD__ #if defined(BKTR_FREEBSD_MODULE) + if (bktr_has_stored_addresses(unit) == 1) { /* recover the addresses */ - 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); + 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); need_to_allocate_memory = 0; } #endif if (need_to_allocate_memory == 1) { - /* 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); - - /* allocte space for the VBI buffer */ - bktr->vbidata = get_bktr_mem(unit, VBI_DATA_SIZE); - bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE); - - /* allocate space for pixel buffer */ - if ( BROOKTREE_ALLOC ) - buf = get_bktr_mem(unit, BROOKTREE_ALLOC); + 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 = 0; + buf_addr = 0; } -#endif /* FreeBSD or BSDi */ - +#endif /* FreeBSD */ /* If this is a module, save the current contiguous memory */ #if defined(BKTR_FREEBSD_MODULE) -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); +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); #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; +#if defined(__FreeBSD__) && (__FreeBSD_version >= 400000) + bktr->bigbuf_addr = buf_addr; +#endif bktr->alloc_pages = BROOKTREE_ALLOC_PAGES; bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC); } else { @@ -749,7 +782,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); @@ -1280,7 +1313,12 @@ video_ioctl( bktr_ptr_t bktr, int unit, struct meteor_counts *counts; struct meteor_video *video; struct bktr_capture_area *cap_area; +#if defined(__FreeBSD__) && (__FreeBSD_version >= 400000) + void *buf; + u_int32_t buf_addr; +#else vm_offset_t buf; +#endif int i; char char_temp; @@ -1744,11 +1782,18 @@ video_ioctl( bktr_ptr_t bktr, int unit, bktr->dm_mem = dmamap; #else - buf = get_bktr_mem(unit, temp*PAGE_SIZE); - if (buf != 0) { - kmem_free(kernel_map, bktr->bigbuf, - (bktr->alloc_pages * PAGE_SIZE)); -#endif + 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; + +#endif /* !__NetBSD__ && !__OpenBSD__ */ bktr->bigbuf = buf; bktr->alloc_pages = temp; @@ -2645,14 +2690,16 @@ static bool_t split(bktr_reg_t * bktr, v skip = 0; if (( flag & OP_SOL ) && ( start_skip > 0 )) { - *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip; + *(*dma_prog)++ = htole32(OP_SKIP | OP_SOL | start_skip); flag &= ~OP_SOL; skip = start_skip; } - *(*dma_prog)++ = operation | flag | (width * pixel_width - skip); + *(*dma_prog)++ = htole32(operation | flag | + (width * pixel_width - skip)); if (operation != OP_SKIP ) - *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer; + *(*dma_prog)++ = htole32((uintptr_t) (volatile void *) + *target_buffer); *target_buffer += width * pixel_width; bktr->current_col += width; @@ -2675,22 +2722,23 @@ static bool_t split(bktr_reg_t * bktr, v skip = 0; if (( flag & OP_SOL ) && ( start_skip > 0 )) { - *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip; + *(*dma_prog)++ = htole32(OP_SKIP | OP_SOL | start_skip); flag &= ~OP_SOL; skip = start_skip; } - *(*dma_prog)++ = operation | flag | - (width * pixel_width / 2 - skip); + *(*dma_prog)++ = htole32(operation | flag | + (width * pixel_width / 2 - skip)); if (operation != OP_SKIP ) - *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer ; - *target_buffer += (width * pixel_width / 2) ; + *(*dma_prog)++ = htole32((uintptr_t)(volatile void *) + *target_buffer); + *target_buffer += (width * pixel_width / 2); if ( operation == OP_WRITE ) operation = OP_WRITEC; - *(*dma_prog)++ = operation | flag2 | - (width * pixel_width / 2); - *target_buffer += (width * pixel_width / 2) ; + *(*dma_prog)++ = htole32(operation | flag2 | + (width * pixel_width / 2)); + *target_buffer += (width * pixel_width / 2); bktr->current_col += width; } @@ -2709,8 +2757,8 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl volatile u_long pitch; volatile u_long *dma_prog; /* DMA prog is an array of 32 bit RISC instructions */ - volatile u_long *loop_point; - struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; + volatile u_long loop_point; + struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; u_int Bpp = pf_int->public.Bpp; unsigned int vbisamples; /* VBI samples per line */ unsigned int vbilines; /* VBI lines per field */ @@ -2754,7 +2802,7 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl pitch = bktr->video.width; } else { - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); pitch = cols*Bpp; } @@ -2763,26 +2811,25 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl /* Wait for the VRE sync marking the end of the Even and * the start of the Odd field. Resync here. */ - *dma_prog++ = OP_SYNC | BKTR_RESYNC |BKTR_VRE; - *dma_prog++ = 0; - - loop_point = dma_prog; + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC |BKTR_VRE); + *dma_prog++ = htole32(0); + loop_point = 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++ = OP_SYNC | BKTR_FM1; *dma_prog++ = 0; for(i = 0; i < vbilines; i++) { - *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples; - *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata + - (i * VBI_LINE_SIZE)); + *dma_prog++ = htole32(OP_WRITE | OP_SOL | OP_EOL | vbisamples); + *dma_prog++ = htole32(VBIDATA_ADDR(bktr) + i * VBI_LINE_SIZE); } if ( (i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/ ) { /* store the Odd field video image */ /* look for sync with packed data */ - *dma_prog++ = OP_SYNC | BKTR_FM1; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_FM1); + *dma_prog++ = htole32(0); /* NULL WORD */ width = cols; for (i = 0; i < (rows/interlace); i++) { target = target_buffer; @@ -2816,17 +2863,17 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl /* Grab the Even field */ /* Look for the VRO, end of Odd field, marker */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO); + *dma_prog++ = htole32(0); /* NULL WORD */ /* store the VBI data */ /* look for sync with packed data */ - *dma_prog++ = OP_SYNC | BKTR_FM1; - *dma_prog++ = 0; + *dma_prog++ = htole32(OP_SYNC | BKTR_FM1); + *dma_prog++ = htole32(0); for(i = 0; i < vbilines; i++) { - *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples; - *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata + - ((i+MAX_VBI_LINES) * VBI_LINE_SIZE)); + *dma_prog++ = htole32(OP_WRITE | OP_SOL | OP_EOL | vbisamples); + *dma_prog++ = htole32((u_long)VBIDATA_ADDR(bktr) + + (i + MAX_VBI_LINES) * VBI_LINE_SIZE); } /* store the video image */ @@ -2838,8 +2885,8 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl if ((i_flag == 1) /*Even Only*/ || (i_flag==3) /*interlaced*/) { /* look for sync with packed data */ - *dma_prog++ = OP_SYNC | BKTR_FM1; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_FM1); + *dma_prog++ = htole32(0); /* NULL WORD */ width = cols; for (i = 0; i < (rows/interlace); i++) { target = target_buffer; @@ -2871,12 +2918,12 @@ rgb_vbi_prog( bktr_ptr_t bktr, char i_fl } /* Look for end of 'Even Field' */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE); + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog++ = (u_long ) vtophys(loop_point) ; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long )loop_point); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -2926,17 +2973,17 @@ rgb_prog( bktr_ptr_t bktr, char i_flag, pitch = bktr->video.width; } else { - target_buffer = (u_long) vtophys(bktr->bigbuf); + target_buffer = (u_long) BUF_ADDR(bktr); pitch = cols*Bpp; } buffer = target_buffer; /* contruct sync : for video packet format */ - *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC | BKTR_FM1); /* sync, mode indicator packed data */ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(0); /* NULL WORD */ width = cols; for (i = 0; i < (rows/interlace); i++) { target = target_buffer; @@ -2969,28 +3016,29 @@ rgb_prog( bktr_ptr_t bktr, char i_flag, switch (i_flag) { case 1: /* sync vre */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO); + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long ) DMA_PROG_ADDR(bktr)); return; case 2: /* sync vro */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE); + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long )DMA_PROG_ADDR(bktr)); return; case 3: /* sync vro */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP; ; - *dma_prog = (u_long ) vtophys(bktr->odd_dma_prog); + *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)ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3001,8 +3049,8 @@ rgb_prog( bktr_ptr_t bktr, char i_flag, dma_prog = (u_long *) bktr->odd_dma_prog; /* sync vre IRQ bit */ - *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC | BKTR_FM1); + *dma_prog++ = htole32(0); /* NULL WORD */ width = cols; for (i = 0; i < (rows/interlace); i++) { target = target_buffer; @@ -3034,11 +3082,11 @@ rgb_prog( bktr_ptr_t bktr, char i_flag, } /* sync vre IRQ bit */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog) ; - *dma_prog++ = 0; /* NULL WORD */ + *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 )DMA_PROG_ADDR(bktr)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3080,49 +3128,49 @@ yuvpack_prog( bktr_ptr_t bktr, char i_fl 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; /* contruct sync : for video packet format */ /* sync, mode indicator packed data */ - *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC | BKTR_FM1); + *dma_prog++ = htole32(0); /* NULL WORD */ b = cols; for (i = 0; i < (rows/interlace); i++) { - *dma_prog++ = inst; - *dma_prog++ = target_buffer; - *dma_prog++ = inst3; - *dma_prog++ = target_buffer + b; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(inst3); + *dma_prog++ = htole32(target_buffer + b); target_buffer += interlace*(cols * 2); } switch (i_flag) { case 1: /* sync vre */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE); + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long )DMA_PROG_ADDR(bktr)); return; case 2: /* sync vro */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *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 )DMA_PROG_ADDR(bktr)); return; case 3: /* sync vro */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog = (u_long ) vtophys(bktr->odd_dma_prog); + *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)ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3133,27 +3181,26 @@ yuvpack_prog( bktr_ptr_t bktr, char i_fl dma_prog = (u_long * ) bktr->odd_dma_prog; /* sync vre */ - *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC | BKTR_FM1); + *dma_prog++ = htole32(0); /* NULL WORD */ for (i = 0; i < (rows/interlace) ; i++) { - *dma_prog++ = inst; - *dma_prog++ = target_buffer; - *dma_prog++ = inst3; - *dma_prog++ = target_buffer + b; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(inst3); + *dma_prog++ = htole32(target_buffer + b); target_buffer += interlace * ( cols*2); } } /* sync vro IRQ bit */ - *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); - - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); - *dma_prog++ = 0; /* NULL WORD */ + *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)DMA_PROG_ADDR(bktr)); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3198,48 +3245,48 @@ yuv422_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; t1 = buffer; /* contruct sync : for video packet format */ - *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; /*sync, mode indicator packed data*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 15 | BKTR_FM3); /*sync, mode indicator packed data*/ + *dma_prog++ = htole32(0); /* NULL WORD */ for (i = 0; i < (rows/interlace ) ; i++) { - *dma_prog++ = inst; - *dma_prog++ = cols/2 | cols/2 << 16; - *dma_prog++ = target_buffer; - *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; - *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(cols / 2 | cols / 2 << 16); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(t1 + (cols*rows) + i*cols/2 * interlace); + *dma_prog++ = htole32(t1 + (cols*rows) + (cols*rows/2) + + i*cols/2 * interlace); target_buffer += interlace*cols; } switch (i_flag) { case 1: - *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRE; /*sync vre*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | BKTR_VRE); /*sync vre*/ + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); return; case 2: - *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRO; /*sync vre*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | BKTR_VRO); /*sync vre*/ + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); return; case 3: - *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO); + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog = (u_long ) vtophys(bktr->odd_dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog = htole32((u_long)ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3249,24 +3296,26 @@ yuv422_prog( bktr_ptr_t bktr, char i_fla target_buffer = (u_long) buffer + cols; t1 = buffer + cols/2; - *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 15 | BKTR_FM3); + *dma_prog++ = htole32(0); /* NULL WORD */ for (i = 0; i < (rows/interlace ) ; i++) { - *dma_prog++ = inst; - *dma_prog++ = cols/2 | cols/2 << 16; - *dma_prog++ = target_buffer; - *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; - *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(cols/2 | cols/2 << 16); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(t1 + (cols*rows) + i*cols/2 * + interlace); + *dma_prog++ = htole32(t1 + (cols*rows) + (cols*rows/2) + + i*cols/2 * interlace); target_buffer += interlace*cols; } } - *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog) ; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE); + *dma_prog++ = htole32(0); /* NULL WORD */ + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3299,50 +3348,51 @@ 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; - *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; /*sync, mode indicator packed data*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 15 | BKTR_FM3); /*sync, mode indicator packed data*/ + *dma_prog++ = htole32(0); /* NULL WORD */ for (i = 0; i < (rows/interlace )/2 ; i++) { - *dma_prog++ = inst; - *dma_prog++ = cols/2 | (cols/2 << 16); - *dma_prog++ = target_buffer; - *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; - *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(cols / 2 | (cols / 2 << 16)); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(t1 + (cols*rows) + i*cols/2 * interlace); + *dma_prog++ = htole32(t1 + (cols*rows) + (cols*rows/4) + + i*cols/2 * interlace); target_buffer += interlace*cols; - *dma_prog++ = inst1; - *dma_prog++ = cols/2 | (cols/2 << 16); - *dma_prog++ = target_buffer; + *dma_prog++ = htole32(inst1); + *dma_prog++ = htole32(cols / 2 | (cols / 2 << 16)); + *dma_prog++ = htole32(target_buffer); target_buffer += interlace*cols; } switch (i_flag) { case 1: - *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRE; /*sync vre*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | BKTR_VRE); /*sync vre*/ + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); return; case 2: - *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRO; /*sync vro*/ - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | BKTR_VRO); /*sync vro*/ + *dma_prog++ = htole32(0); /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); return; case 3: - *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP ; - *dma_prog = (u_long ) vtophys(bktr->odd_dma_prog); + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO); + *dma_prog++ = htole32(0); /* NULL WORD */ + *dma_prog++ = htole32(OP_JUMP); + *dma_prog = htole32((u_long )ODD_DMA_PROG_ADDR(bktr)); break; } @@ -3352,19 +3402,21 @@ yuv12_prog( bktr_ptr_t bktr, char i_flag target_buffer = (u_long) buffer + cols; t1 = buffer + cols/2; - *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 15 | BKTR_FM3); + *dma_prog++ = htole32(0); /* NULL WORD */ for (i = 0; i < ((rows/interlace )/2 ) ; i++) { - *dma_prog++ = inst; - *dma_prog++ = cols/2 | (cols/2 << 16); - *dma_prog++ = target_buffer; - *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; - *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace; + *dma_prog++ = htole32(inst); + *dma_prog++ = htole32(cols / 2 | (cols / 2 << 16)); + *dma_prog++ = htole32(target_buffer); + *dma_prog++ = htole32(t1 + (cols*rows) + i*cols/2 * + interlace); + *dma_prog++ = htole32(t1 + (cols*rows) + (cols*rows/4) + + i*cols/2 * interlace); target_buffer += interlace*cols; - *dma_prog++ = inst1; - *dma_prog++ = cols/2 | (cols/2 << 16); - *dma_prog++ = target_buffer; + *dma_prog++ = htole32(inst1); + *dma_prog++ = htole32(cols/2 | (cols/2 << 16)); + *dma_prog++ = htole32(target_buffer); target_buffer += interlace*cols; } @@ -3372,11 +3424,11 @@ yuv12_prog( bktr_ptr_t bktr, char i_flag } - *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE; - *dma_prog++ = 0; /* NULL WORD */ - *dma_prog++ = OP_JUMP; - *dma_prog++ = (u_long ) vtophys(bktr->dma_prog); - *dma_prog++ = 0; /* NULL WORD */ + *dma_prog++ = htole32(OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE); + *dma_prog++ = htole32(0); /* NULL WORD */ + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)DMA_PROG_ADDR(bktr)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3535,7 +3587,7 @@ build_dma_prog( bktr_ptr_t bktr, char i_ 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; @@ -3644,7 +3696,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)); } @@ -3709,18 +3761,27 @@ static u_int pixfmt_swap_flags( int pixf { struct meteor_pixfmt *pf = &pixfmt_table[ pixfmt ].public; u_int swapf = 0; + int swap_bytes, swap_shorts; + +#if BYTE_ORDER == LITTLE_ENDIAN + swap_bytes = pf->swap_bytes; + swap_shorts = pf->swap_shorts; +#else + swap_bytes = !pf->swap_bytes; + swap_shorts = !pf->swap_shorts; +#endif switch ( pf->Bpp ) { - case 2 : swapf = ( pf->swap_bytes ? 0 : BSWAP ); + case 2 : swapf = ( swap_bytes ? 0 : BSWAP ); break; case 3 : /* no swaps supported for 3bpp - makes no sense w/ bt848 */ break; - case 4 : if ( pf->swap_bytes ) - swapf = pf->swap_shorts ? 0 : WSWAP; + case 4 : if ( swap_bytes ) + swapf = swap_shorts ? 0 : WSWAP; else - swapf = pf->swap_shorts ? BSWAP : (BSWAP | WSWAP); + swapf = swap_shorts ? BSWAP : (BSWAP | WSWAP); break; } return swapf; Index: bktr_mem.c =================================================================== RCS file: /space3/ncvs/src/sys/dev/bktr/bktr_mem.c,v retrieving revision 1.6 diff -u -p -r1.6 bktr_mem.c --- bktr_mem.c 26 Nov 2001 04:06:47 -0000 1.6 +++ bktr_mem.c 13 Feb 2003 04:06:51 -0000 @@ -45,19 +45,36 @@ * POSSIBILITY OF SUCH DAMAGE. */ - #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]; @@ -111,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" @@ -120,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); @@ -143,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: /space3/ncvs/src/sys/dev/bktr/bktr_mem.h,v retrieving revision 1.1 diff -u -p -r1.1 bktr_mem.h --- bktr_mem.h 10 Sep 2000 14:34:08 -0000 1.1 +++ bktr_mem.h 13 Feb 2003 04:06:51 -0000 @@ -58,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: /space3/ncvs/src/sys/dev/bktr/bktr_os.c,v retrieving revision 1.31 diff -u -p -r1.31 bktr_os.c --- bktr_os.c 9 Dec 2002 09:04:09 -0000 1.31 +++ bktr_os.c 13 Feb 2003 04:06:51 -0000 @@ -264,7 +264,6 @@ static struct cdevsw bktr_cdevsw = { DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0); #if (__FreeBSD_version > 410000) -MODULE_DEPEND(bktr, bktr_mem, 1,1,1); MODULE_VERSION(bktr, 1); #endif @@ -529,23 +528,72 @@ bktr_shutdown( device_t dev ) /* * Special Memory Allocation */ +#if (__FreeBSD_version >= 400000) +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; +} + vm_offset_t -get_bktr_mem( int unit, unsigned size ) +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); +} +#else +vm_offset_t +get_bktr_mem( int unit, unsigned size ) +{ + vm_offset_t addr = 0; + + 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); + } + return( addr ); +} +#endif /* FreeBSD_version */ /*--------------------------------------------------------- ** ** BrookTree 848 character device driver routines @@ -779,7 +827,7 @@ bktr_mmap( dev_t dev, vm_offset_t offset if (offset >= bktr->alloc_pages * PAGE_SIZE) return( -1 ); - return( atop(vtophys(bktr->bigbuf) + offset) ); + return(atop(vtophys(bktr->bigbuf) + offset)); } static int @@ -1292,3 +1340,64 @@ bktr_mmap(dev_t dev, off_t offset, int n } #endif /* __NetBSD__ || __OpenBSD__ */ + +#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) +u_int8_t +bktr_INB(struct bktr_softc *bktr, int offset) +{ + + u_int8_t val = bus_space_read_1(bktr->memt, bktr->memh, offset); + bus_space_barrier(bktr->memt, bktr->memh, offset, 1, + BUS_SPACE_BARRIER_READ); + return val; +} + +u_int16_t +bktr_INW(struct bktr_softc *bktr, int offset) +{ + + u_int16_t val = bus_space_read_2(bktr->memt, bktr->memh, offset); + bus_space_barrier(bktr->memt, bktr->memh, offset, 2, + BUS_SPACE_BARRIER_READ); + return val; +} + +u_int32_t +bktr_INL(struct bktr_softc *bktr, int offset) +{ + + u_int32_t val = bus_space_read_4(bktr->memt, bktr->memh, offset); + bus_space_barrier(bktr->memt, bktr->memh, offset, 4, + BUS_SPACE_BARRIER_READ); + return val; +} + +void +bktr_OUTB(struct bktr_softc *bktr, int offset, u_int8_t value) +{ + + bus_space_write_1(bktr->memt, bktr->memh, offset, value); + bus_space_barrier(bktr->memt, bktr->memh, offset, 1, + BUS_SPACE_BARRIER_WRITE); +} + +void +bktr_OUTW(struct bktr_softc *bktr, int offset, u_int16_t value) +{ + + bus_space_write_2(bktr->memt, bktr->memh, offset, value); + bus_space_barrier(bktr->memt, bktr->memh, offset, 2, + BUS_SPACE_BARRIER_WRITE); +} + +void +bktr_OUTL(struct bktr_softc *bktr, int offset, u_int32_t value) +{ + + bus_space_write_4(bktr->memt, bktr->memh, offset, value); + bus_space_barrier(bktr->memt, bktr->memh, offset, 4, + BUS_SPACE_BARRIER_WRITE); +} + +#endif /* __NetBSD__ || __FreeBSD__ */ + Index: bktr_os.h =================================================================== RCS file: /space3/ncvs/src/sys/dev/bktr/bktr_os.h,v retrieving revision 1.6 diff -u -p -r1.6 bktr_os.h --- bktr_os.h 18 Dec 2001 00:27:15 -0000 1.6 +++ bktr_os.h 13 Feb 2003 04:06:51 -0000 @@ -47,15 +47,37 @@ /******************************/ /* *** Memory Allocation *** */ /******************************/ -#if (defined(__FreeBSD__) || defined(__bsdi__)) +#if (defined(__bsdi__) || (defined(__FreeBSD__) && (__FreeBSD_version < 400000))) vm_offset_t get_bktr_mem( int unit, unsigned size ); #endif -#if (defined(__NetBSD__) || defined(__OpenBSD__)) +#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__) || defined(__OpenBSD__)) vm_offset_t get_bktr_mem(bktr_ptr_t, bus_dmamap_t *, unsigned size); void free_bktr_mem(bktr_ptr_t, bus_dmamap_t, vm_offset_t); #endif +#define FreeBSD_busdma (defined(__FreeBSD__) && (__FreeBSD_version >= 400000)) + +#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 *** */ /************************************/ Index: bktr_reg.h =================================================================== RCS file: /space3/ncvs/src/sys/dev/bktr/bktr_reg.h,v retrieving revision 1.44 diff -u -p -r1.44 bktr_reg.h --- bktr_reg.h 25 Mar 2002 21:22:33 -0000 1.44 +++ bktr_reg.h 13 Feb 2003 04:06:51 -0000 @@ -461,13 +461,22 @@ struct bktr_i2c_softc { * memory mapped structure method only works on 32 bit processors * with the right type of endianness. */ -#if defined(__NetBSD__) || ( defined(__FreeBSD__) && (__FreeBSD_version >=300000) ) -#define INB(bktr,offset) bus_space_read_1((bktr)->memt,(bktr)->memh,(offset)) -#define INW(bktr,offset) bus_space_read_2((bktr)->memt,(bktr)->memh,(offset)) -#define INL(bktr,offset) bus_space_read_4((bktr)->memt,(bktr)->memh,(offset)) -#define OUTB(bktr,offset,value) bus_space_write_1((bktr)->memt,(bktr)->memh,(offset),(value)) -#define OUTW(bktr,offset,value) bus_space_write_2((bktr)->memt,(bktr)->memh,(offset),(value)) -#define OUTL(bktr,offset,value) bus_space_write_4((bktr)->memt,(bktr)->memh,(offset),(value)) +#if defined(__NetBSD__) || defined(__OpenBSD__) || \ + ( defined(__FreeBSD__) && (__FreeBSD_version >=300000) ) +struct bktr_softc; + +u_int8_t bktr_INB(struct bktr_softc *, int); +u_int16_t bktr_INW(struct bktr_softc *, int); +u_int32_t bktr_INL(struct bktr_softc *, int); +void bktr_OUTB(struct bktr_softc *, int, u_int8_t); +void bktr_OUTW(struct bktr_softc *, int, u_int16_t); +void bktr_OUTL(struct bktr_softc *, int, u_int32_t); +#define INB(bktr,offset) bktr_INB(bktr,offset) +#define INW(bktr,offset) bktr_INW(bktr,offset) +#define INL(bktr,offset) bktr_INL(bktr,offset) +#define OUTB(bktr,offset,value) bktr_OUTB(bktr,offset,value) +#define OUTW(bktr,offset,value) bktr_OUTW(bktr,offset,value) +#define OUTL(bktr,offset,value) bktr_OUTL(bktr,offset,value) #else #define INB(bktr,offset) *(volatile unsigned char*) ((int)((bktr)->memh)+(offset)) #define INW(bktr,offset) *(volatile unsigned short*)((int)((bktr)->memh)+(offset)) @@ -530,6 +539,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 */ @@ -561,6 +580,17 @@ struct bktr_softc { 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__) && (__FreeBSD_version >= 400000) + u_int32_t bigbuf_addr; + void *bigbuf; + u_int32_t vbidata_addr; + void *vbidata; + u_int32_t vbibuffer_addr; + void *vbibuffer; + u_int32_t dma_prog_addr; + void *dma_prog; + u_int32_t odd_dma_prog_addr; + void *odd_dma_prog; #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 */