diff -Nup saved_bktr/bktr_core.c bktr/bktr_core.c --- saved_bktr/bktr_core.c Tue Feb 11 01:48:32 2003 +++ bktr/bktr_core.c Tue Feb 11 02:05:09 2003 @@ -1,4 +1,4 @@ -/* $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.103.2.4 2000/11/01 09:36:14 roger Exp $ */ +/* $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.124 2002/12/07 09:00:19 roger Exp $ */ /* * This is part of the Driver for Video Capture Cards (Frame grabbers) @@ -96,12 +96,8 @@ #include "opt_bktr.h" /* Include any kernel config options */ -#ifdef __FreeBSD__ -#include "bktr.h" -#endif /* __FreeBSD__ */ - #if ( \ - (defined(__FreeBSD__) && (NBKTR > 0)) \ + (defined(__FreeBSD__)) \ || (defined(__bsdi__)) \ || (defined(__OpenBSD__)) \ || (defined(__NetBSD__)) \ @@ -116,8 +112,11 @@ #include #include #include +#include +#include #include #include +#include #include #include @@ -130,6 +129,8 @@ #if (__FreeBSD_version < 500000) #include /* for DELAY */ +#define PROC_LOCK(p) +#define PROC_UNLOCK(p) #endif #include @@ -167,9 +168,6 @@ bktr_name(bktr_ptr_t bktr) } -#if (__FreeBSD__ == 2) -typedef unsigned int uintptr_t; -#endif #endif /* __FreeBSD__ */ @@ -177,6 +175,8 @@ typedef unsigned int uintptr_t; /* *** BSDI *** */ /****************/ #ifdef __bsdi__ +#define PROC_LOCK(p) +#define PROC_UNLOCK(p) #endif /* __bsdi__ */ @@ -217,6 +217,9 @@ bktr_name(bktr_ptr_t bktr) return (bktr->bktr_dev.dv_xname); } +#define PROC_LOCK(p) +#define PROC_UNLOCK(p) + #endif /* __NetBSD__ || __OpenBSD__ */ @@ -466,9 +469,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 *** */ /***************************************/ @@ -492,56 +499,81 @@ 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 0x%x\n", - bktr_name(bktr), BROOKTREE_ALLOC, vtophys(buf)); + printf("%s: buffer size %d, addr %p\n", + bktr_name(bktr), BROOKTREE_ALLOC, + (void *)GET_ADDR(buf)); } 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 { @@ -745,7 +777,7 @@ common_bktr_intr( void *arg ) } } - OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); + OUTL(bktr, BKTR_RISC_STRT_ADD, GET_ADDR(bktr->dma_prog)); OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); @@ -806,7 +838,6 @@ common_bktr_intr( void *arg ) } - /* * Register the completed field * (For dual-field mode, require fields from the same frame) @@ -895,9 +926,12 @@ common_bktr_intr( void *arg ) * let them know the frame is complete. */ - if (bktr->proc && !(bktr->signal & METEOR_SIG_MODE_MASK)) + if (bktr->proc && !(bktr->signal & METEOR_SIG_MODE_MASK)) { + PROC_LOCK(bktr->proc); psignal( bktr->proc, bktr->signal&(~METEOR_SIG_MODE_MASK) ); + PROC_UNLOCK(bktr->proc); + } /* * Reset the want flags if in continuous or @@ -1023,7 +1057,7 @@ video_open( bktr_ptr_t bktr ) bktr->frames_captured = 0; bktr->even_fields_captured = 0; bktr->odd_fields_captured = 0; - bktr->proc = (struct proc *)0; + bktr->proc = NULL; set_fps(bktr, frame_rate); bktr->video.addr = 0; bktr->video.width = 0; @@ -1264,7 +1298,7 @@ vbi_read(bktr_ptr_t bktr, struct uio *ui * video ioctls */ int -video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ) +video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* p ) { volatile u_char c_temp; unsigned int temp; @@ -1274,7 +1308,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; @@ -1552,7 +1591,7 @@ video_ioctl( bktr_ptr_t bktr, int unit, break; } bktr->signal = *(int *) arg; - bktr->proc = pr; + bktr->proc = p; break; case METEORGSIGNAL: @@ -1737,12 +1776,24 @@ video_ioctl( bktr_ptr_t bktr, int unit, bktr->bigbuf); bktr->dm_mem = dmamap; +#elif (__FreeBSD_version >= 400000) + 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, (bktr->alloc_pages * PAGE_SIZE)); -#endif +#endif /* !__NetBSD__ && !__OpenBSD__ */ bktr->bigbuf = buf; bktr->alloc_pages = temp; @@ -1873,7 +1924,7 @@ video_ioctl( bktr_ptr_t bktr, int unit, * tuner ioctls */ int -tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* pr ) +tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct proc* p ) { int tmp_int; unsigned int temp, temp1; @@ -2292,7 +2343,7 @@ tuner_ioctl( bktr_ptr_t bktr, int unit, /* * common ioctls */ -int +static int common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg ) { int pixfmt; @@ -2538,7 +2589,7 @@ dump_bt848( bktr_ptr_t bktr ) #define BKTR_TEST_RISC_STATUS_BIT2 (1 << 30) #define BKTR_TEST_RISC_STATUS_BIT3 (1 << 31) -bool_t notclipped (bktr_reg_t * bktr, int x, int width) { +static bool_t notclipped (bktr_reg_t * bktr, int x, int width) { int i; bktr_clip_t * clip_node; bktr->clip_start = -1; @@ -2565,7 +2616,7 @@ bool_t notclipped (bktr_reg_t * bktr, in return TRUE; } -bool_t getline(bktr_reg_t *bktr, int x ) { +static bool_t getline(bktr_reg_t *bktr, int x ) { int i, j; bktr_clip_t * clip_node ; @@ -2639,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; @@ -2669,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; } @@ -2703,8 +2757,12 @@ 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 */ +#if FreeBSD_busdma + volatile u_long loop_point; +#else volatile u_long *loop_point; - struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; +#endif + 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 */ @@ -2748,7 +2806,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) GET_ADDR(bktr->bigbuf); pitch = cols*Bpp; } @@ -2757,46 +2815,54 @@ 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; + *dma_prog++ = htole32(OP_SYNC | BKTR_RESYNC |BKTR_VRE); + *dma_prog++ = htole32(0); +#if FreeBSD_busdma + loop_point = bktr->dma_prog_addr + + ((u_long) dma_prog - (u_long) bktr->dma_prog); +#else loop_point = dma_prog; - +#endif /* 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); +#if FreeBSD_busdma + *dma_prog++ = htole32(bktr->vbidata_addr + i * VBI_LINE_SIZE); +#else + *dma_prog++ = htole32((u_long)vtophys((caddr_t)bktr->vbidata + + (i * VBI_LINE_SIZE))); +#endif } 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; if ( notclipped(bktr, i, width)) { 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); } else { while(getline(bktr, i)) { 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, bktr->yclip2 - bktr->yclip, OP_SKIP, - Bpp, (volatile u_char **) &target, cols); + Bpp, (volatile u_char **)(uintptr_t)&target, cols); } } @@ -2810,17 +2876,22 @@ 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); +#if FreeBSD_busdma + *dma_prog++ = htole32((u_long)bktr->vbidata_addr + + (i + MAX_VBI_LINES) * VBI_LINE_SIZE); +#else + *dma_prog++ = htole32((u_long) vtophys((caddr_t)bktr->vbidata + + ((i+MAX_VBI_LINES) * VBI_LINE_SIZE))); +#endif } /* store the video image */ @@ -2832,27 +2903,27 @@ 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; if ( notclipped(bktr, i, width)) { 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); } else { while(getline(bktr, i)) { if (bktr->y != bktr->y2 ) { split(bktr, (volatile u_long **) &dma_prog, bktr->y2 - bktr->y, OP_WRITE, - Bpp, (volatile u_char **) &target, + Bpp, (volatile u_char **)(uintptr_t)&target, cols); } if (bktr->yclip != bktr->yclip2 ) { split(bktr, (volatile u_long **) &dma_prog, bktr->yclip2 - bktr->yclip, OP_SKIP, - Bpp, (volatile u_char **) &target, cols); + Bpp, (volatile u_char **)(uintptr_t) &target, cols); } } @@ -2865,12 +2936,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 */ } @@ -2920,37 +2991,37 @@ 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) GET_ADDR(bktr->bigbuf); 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; if ( notclipped(bktr, i, width)) { 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); } else { while(getline(bktr, i)) { 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, bktr->yclip2 - bktr->yclip, OP_SKIP, - Bpp, (volatile u_char **) &target, cols); + Bpp, (volatile u_char **)(uintptr_t)&target, cols); } } @@ -2963,28 +3034,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 ) GET_ADDR(bktr->dma_prog)); 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 )GET_ADDR(bktr->dma_prog)); 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)GET_ADDR(bktr->odd_dma_prog)); break; } @@ -2995,27 +3067,27 @@ 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; if ( notclipped(bktr, i, width)) { 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); } else { while(getline(bktr, i)) { if (bktr->y != bktr->y2 ) { split(bktr, (volatile u_long **) &dma_prog, bktr->y2 - bktr->y, OP_WRITE, - Bpp, (volatile u_char **) &target, + Bpp, (volatile u_char **)(uintptr_t)&target, cols); } if (bktr->yclip != bktr->yclip2 ) { split(bktr, (volatile u_long **) &dma_prog, bktr->yclip2 - bktr->yclip, OP_SKIP, - Bpp, (volatile u_char **) &target, cols); + Bpp, (volatile u_char **)(uintptr_t)&target, cols); } } @@ -3028,11 +3100,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 )GET_ADDR(bktr->dma_prog)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3074,49 +3146,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) GET_ADDR(bktr->bigbuf); buffer = target_buffer; /* contruct sync : for video packet format */ /* sync, mode indicator packed data */ - *dma_prog++ = OP_SYNC | 1 << 15 | 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 | 1 << 24 | 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 )GET_ADDR(bktr->dma_prog)); return; case 2: /* sync vro */ - *dma_prog++ = OP_SYNC | 1 << 24 | 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 )GET_ADDR(bktr->dma_prog)); return; case 3: /* sync vro */ - *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 | BKTR_GEN_IRQ | BKTR_RESYNC | + BKTR_VRO); + *dma_prog++ = htole32(0); /* NULL WORD */ + *dma_prog++ = htole32(OP_JUMP); + *dma_prog = htole32((u_long)GET_ADDR(bktr->odd_dma_prog)); break; } @@ -3127,27 +3199,26 @@ yuvpack_prog( bktr_ptr_t bktr, char i_fl dma_prog = (u_long * ) bktr->odd_dma_prog; /* sync vre */ - *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | 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 | 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++ = 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)GET_ADDR(bktr->dma_prog)); + *dma_prog++ = htole32(OP_JUMP); + *dma_prog++ = htole32((u_long)GET_ADDR(bktr->dma_prog)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3192,48 +3263,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) GET_ADDR(bktr->bigbuf); 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)GET_ADDR(bktr->dma_prog)); 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)GET_ADDR(bktr->dma_prog)); 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)GET_ADDR(bktr->odd_dma_prog)); break; } @@ -3243,24 +3314,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)GET_ADDR(bktr->dma_prog)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3293,50 +3366,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) GET_ADDR(bktr->bigbuf); 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)GET_ADDR(bktr->dma_prog)); 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)GET_ADDR(bktr->dma_prog)); 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 )GET_ADDR(bktr->odd_dma_prog)); break; } @@ -3346,19 +3420,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; } @@ -3366,11 +3442,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)GET_ADDR(bktr->dma_prog)); + *dma_prog++ = htole32(0); /* NULL WORD */ } @@ -3529,7 +3605,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, GET_ADDR(bktr->dma_prog)); rows = bktr->rows; cols = bktr->cols; @@ -3638,7 +3714,7 @@ start_capture( bktr_ptr_t bktr, unsigned } - OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); + OUTL(bktr, BKTR_RISC_STRT_ADD, GET_ADDR(bktr->dma_prog)); } @@ -3703,18 +3779,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; diff -Nup saved_bktr/bktr_mem.c bktr/bktr_mem.c --- saved_bktr/bktr_mem.c Tue Feb 11 01:48:32 2003 +++ bktr/bktr_mem.c Tue Feb 11 02:06:21 2003 @@ -48,15 +48,35 @@ #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]; @@ -110,7 +130,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" @@ -119,20 +141,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); @@ -142,19 +179,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; } diff -Nup saved_bktr/bktr_mem.h bktr/bktr_mem.h --- saved_bktr/bktr_mem.h Tue Feb 11 01:48:32 2003 +++ bktr/bktr_mem.h Tue Feb 11 01:53:41 2003 @@ -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); diff -Nup saved_bktr/bktr_os.c bktr/bktr_os.c --- saved_bktr/bktr_os.c Tue Feb 11 01:48:32 2003 +++ bktr/bktr_os.c Tue Feb 11 01:53:41 2003 @@ -250,7 +250,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 @@ -521,23 +520,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 @@ -771,7 +819,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(GET_ADDR(bktr->bigbuf) + offset)); } int bktr_poll( dev_t dev, int events, struct proc *p) @@ -1747,3 +1795,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__ */ + diff -Nup saved_bktr/bktr_os.h bktr/bktr_os.h --- saved_bktr/bktr_os.h Tue Feb 11 01:48:32 2003 +++ bktr/bktr_os.h Tue Feb 11 01:53:41 2003 @@ -47,15 +47,29 @@ /******************************/ /* *** 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)) + +#if FreeBSD_busdma +#define GET_ADDR(x) x##_addr +#else +#define GET_ADDR(x) vtophys(x) +#endif /************************************/ /* *** Interrupt Enable/Disable *** */ /************************************/ diff -Nup saved_bktr/bktr_reg.h bktr/bktr_reg.h --- saved_bktr/bktr_reg.h Tue Feb 11 01:48:32 2003 +++ bktr/bktr_reg.h Tue Feb 11 01:53:41 2003 @@ -470,13 +470,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)) @@ -539,6 +548,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 */ @@ -570,6 +589,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 */