1 /* 2 * 1. Redistributions of source code must retain the 3 * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Amancio Hasty and 17 * Roger Hardiman 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 30 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 /*- 34 * 1. Redistributions of source code must retain the 35 * Copyright (c) 1995 Mark Tinguely and Jim Lowe 36 * All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. All advertising materials mentioning features or use of this software 47 * must display the following acknowledgement: 48 * This product includes software developed by Mark Tinguely and Jim Lowe 49 * 4. The name of the author may not be used to endorse or promote products 50 * derived from this software without specific prior written permission. 51 * 52 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 53 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 54 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 55 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 56 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 57 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 58 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 60 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 61 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 62 * POSSIBILITY OF SUCH DAMAGE. 63 * 64 * $FreeBSD: src/sys/dev/bktr/bktr_core.c,v 1.138 2005/01/09 17:42:03 cognet Exp 65 * $DragonFly: src/sys/dev/video/bktr/bktr_core.c,v 1.15 2005/06/10 23:25:05 dillon Exp $ 66 */ 67 68 /* 69 * This is part of the Driver for Video Capture Cards (Frame grabbers) 70 * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879 71 * chipset. 72 * Copyright Roger Hardiman and Amancio Hasty. 73 * 74 * bktr_core : This deals with the Bt848/849/878/879 PCI Frame Grabber, 75 * Handles all the open, close, ioctl and read userland calls. 76 * Sets the Bt848 registers and generates RISC pograms. 77 * Controls the i2c bus and GPIO interface. 78 * Contains the interface to the kernel. 79 * (eg probe/attach and open/close/ioctl) 80 */ 81 82 /* 83 The Brooktree BT848 Driver driver is based upon Mark Tinguely and 84 Jim Lowe's driver for the Matrox Meteor PCI card . The 85 Philips SAA 7116 and SAA 7196 are very different chipsets than 86 the BT848. 87 88 The original copyright notice by Mark and Jim is included mostly 89 to honor their fantastic work in the Matrox Meteor driver! 90 */ 91 92 #include "opt_bktr.h" /* Include any kernel config options */ 93 94 #include <sys/param.h> 95 #include <sys/systm.h> 96 #include <sys/kernel.h> 97 #include <sys/lock.h> 98 #include <sys/proc.h> 99 #include <sys/signalvar.h> 100 #include <sys/vnode.h> 101 102 #include <vm/vm.h> 103 #include <vm/vm_kern.h> 104 #include <vm/pmap.h> 105 #include <vm/vm_extern.h> 106 107 #include <sys/bus.h> /* used by smbus and newbus */ 108 109 #define PROC_LOCK(p) 110 #define PROC_UNLOCK(p) 111 #include <bus/pci/pcivar.h> 112 #include <bus/pci/pcidevs.h> 113 114 #include <machine/bus_memio.h> /* for bus space */ 115 #include <machine/bus.h> 116 #include <sys/bus.h> 117 #include <sys/thread2.h> 118 119 #include <dev/video/meteor/ioctl_meteor.h> 120 #include <dev/video/bktr/ioctl_bt848.h> /* extensions to ioctl_meteor.h */ 121 #include <dev/video/bktr/bktr_reg.h> 122 #include <dev/video/bktr/bktr_tuner.h> 123 #include <dev/video/bktr/bktr_card.h> 124 #include <dev/video/bktr/bktr_audio.h> 125 #include <dev/video/bktr/bktr_os.h> 126 #include <dev/video/bktr/bktr_core.h> 127 #if defined(BKTR_FREEBSD_MODULE) 128 #include <dev/video/bktr/bktr_mem.h> 129 #endif 130 131 #if defined(BKTR_USE_FREEBSD_SMBUS) 132 #include <dev/video/bktr/bktr_i2c.h> 133 #include <bus/smbus/smbconf.h> 134 #include <bus/iicbus/iiconf.h> 135 #include "smbus_if.h" 136 #include "iicbus_if.h" 137 #endif 138 139 const char * 140 bktr_name(bktr_ptr_t bktr) 141 { 142 return bktr->bktr_xname; 143 } 144 145 typedef u_char bool_t; 146 147 #define BKTRPRI PCATCH 148 #define VBIPRI PCATCH 149 150 151 /* 152 * memory allocated for DMA programs 153 */ 154 #define DMA_PROG_ALLOC (8 * PAGE_SIZE) 155 156 /* When to split a dma transfer , the bt848 has timing as well as 157 dma transfer size limitations so that we have to split dma 158 transfers into two dma requests 159 */ 160 #define DMA_BT848_SPLIT 319*2 161 162 /* 163 * Allocate enough memory for: 164 * 768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages 165 * 166 * You may override this using the options "BROOKTREE_ALLOC_PAGES=value" 167 * in your kernel configuration file. 168 */ 169 170 #ifndef BROOKTREE_ALLOC_PAGES 171 #define BROOKTREE_ALLOC_PAGES 217*4 172 #endif 173 #define BROOKTREE_ALLOC (BROOKTREE_ALLOC_PAGES * PAGE_SIZE) 174 175 /* Definitions for VBI capture. 176 * There are 16 VBI lines in a PAL video field (32 in a frame), 177 * and we take 2044 samples from each line (placed in a 2048 byte buffer 178 * for alignment). 179 * VBI lines are held in a circular buffer before being read by a 180 * user program from /dev/vbi. 181 */ 182 183 #define MAX_VBI_LINES 16 /* Maximum for all vidoe formats */ 184 #define VBI_LINE_SIZE 2048 /* Store upto 2048 bytes per line */ 185 #define VBI_BUFFER_ITEMS 20 /* Number of frames we buffer */ 186 #define VBI_DATA_SIZE (VBI_LINE_SIZE * MAX_VBI_LINES * 2) 187 #define VBI_BUFFER_SIZE (VBI_DATA_SIZE * VBI_BUFFER_ITEMS) 188 189 190 /* Defines for fields */ 191 #define ODD_F 0x01 192 #define EVEN_F 0x02 193 194 195 /* 196 * Parameters describing size of transmitted image. 197 */ 198 199 static struct format_params format_params[] = { 200 /* # define BT848_IFORM_F_AUTO (0x0) - don't matter. */ 201 { 525, 26, 480, 910, 135, 754, 640, 780, 30, 0x68, 0x5d, BT848_IFORM_X_AUTO, 202 12, 1600 }, 203 /* # define BT848_IFORM_F_NTSCM (0x1) */ 204 { 525, 26, 480, 910, 135, 754, 640, 780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0, 205 12, 1600 }, 206 /* # define BT848_IFORM_F_NTSCJ (0x2) */ 207 { 525, 22, 480, 910, 135, 754, 640, 780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0, 208 12, 1600 }, 209 /* # define BT848_IFORM_F_PALBDGHI (0x3) */ 210 { 625, 32, 576, 1135, 186, 924, 768, 944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1, 211 16, 2044 }, 212 /* # define BT848_IFORM_F_PALM (0x4) */ 213 { 525, 22, 480, 910, 135, 754, 640, 780, 30, 0x68, 0x5d, BT848_IFORM_X_XT0, 214 12, 1600 }, 215 /* # define BT848_IFORM_F_PALN (0x5) */ 216 { 625, 32, 576, 1135, 186, 924, 768, 944, 25, 0x7f, 0x72, BT848_IFORM_X_XT1, 217 16, 2044 }, 218 /* # define BT848_IFORM_F_SECAM (0x6) */ 219 { 625, 32, 576, 1135, 186, 924, 768, 944, 25, 0x7f, 0xa0, BT848_IFORM_X_XT1, 220 16, 2044 }, 221 /* # define BT848_IFORM_F_RSVD (0x7) - ???? */ 222 { 625, 32, 576, 1135, 186, 924, 768, 944, 25, 0x7f, 0x72, BT848_IFORM_X_XT0, 223 16, 2044 }, 224 }; 225 226 /* 227 * Table of supported Pixel Formats 228 */ 229 230 static struct meteor_pixfmt_internal { 231 struct meteor_pixfmt public; 232 u_int color_fmt; 233 } pixfmt_table[] = { 234 235 { { 0, METEOR_PIXTYPE_RGB, 2, { 0x7c00, 0x03e0, 0x001f }, 0,0 }, 0x33 }, 236 { { 0, METEOR_PIXTYPE_RGB, 2, { 0x7c00, 0x03e0, 0x001f }, 1,0 }, 0x33 }, 237 238 { { 0, METEOR_PIXTYPE_RGB, 2, { 0xf800, 0x07e0, 0x001f }, 0,0 }, 0x22 }, 239 { { 0, METEOR_PIXTYPE_RGB, 2, { 0xf800, 0x07e0, 0x001f }, 1,0 }, 0x22 }, 240 241 { { 0, METEOR_PIXTYPE_RGB, 3, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x11 }, 242 243 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,0 }, 0x00 }, 244 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x00 }, 245 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,0 }, 0x00 }, 246 { { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x00 }, 247 { { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 }, 248 { { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 }, 0x44 }, 249 { { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 }, 0x88 }, 250 251 }; 252 #define PIXFMT_TABLE_SIZE ( sizeof(pixfmt_table) / sizeof(pixfmt_table[0]) ) 253 254 /* 255 * Table of Meteor-supported Pixel Formats (for SETGEO compatibility) 256 */ 257 258 /* FIXME: Also add YUV_422 and YUV_PACKED as well */ 259 static struct { 260 u_long meteor_format; 261 struct meteor_pixfmt public; 262 } meteor_pixfmt_table[] = { 263 { METEOR_GEO_YUV_12, 264 { 0, METEOR_PIXTYPE_YUV_12, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 } 265 }, 266 267 /* FIXME: Should byte swap flag be on for this one; negative in drvr? */ 268 { METEOR_GEO_YUV_422, 269 { 0, METEOR_PIXTYPE_YUV, 2, { 0xff0000,0x00ff00,0x0000ff }, 1,1 } 270 }, 271 { METEOR_GEO_YUV_PACKED, 272 { 0, METEOR_PIXTYPE_YUV_PACKED, 2, { 0xff0000,0x00ff00,0x0000ff }, 0,1 } 273 }, 274 { METEOR_GEO_RGB16, 275 { 0, METEOR_PIXTYPE_RGB, 2, { 0x7c00, 0x03e0, 0x001f }, 0, 0 } 276 }, 277 { METEOR_GEO_RGB24, 278 { 0, METEOR_PIXTYPE_RGB, 4, { 0xff0000, 0x00ff00, 0x0000ff }, 0, 0 } 279 }, 280 281 }; 282 #define METEOR_PIXFMT_TABLE_SIZE ( sizeof(meteor_pixfmt_table) / \ 283 sizeof(meteor_pixfmt_table[0]) ) 284 285 286 #define BSWAP (BT848_COLOR_CTL_BSWAP_ODD | BT848_COLOR_CTL_BSWAP_EVEN) 287 #define WSWAP (BT848_COLOR_CTL_WSWAP_ODD | BT848_COLOR_CTL_WSWAP_EVEN) 288 289 290 291 /* sync detect threshold */ 292 #if 0 293 #define SYNC_LEVEL (BT848_ADC_RESERVED | \ 294 BT848_ADC_CRUSH) /* threshold ~125 mV */ 295 #else 296 #define SYNC_LEVEL (BT848_ADC_RESERVED | \ 297 BT848_ADC_SYNC_T) /* threshold ~75 mV */ 298 #endif 299 300 301 302 303 /* debug utility for holding previous INT_STAT contents */ 304 #define STATUS_SUM 305 static u_long status_sum = 0; 306 307 /* 308 * defines to make certain bit-fiddles understandable 309 */ 310 #define FIFO_ENABLED BT848_DMA_CTL_FIFO_EN 311 #define RISC_ENABLED BT848_DMA_CTL_RISC_EN 312 #define FIFO_RISC_ENABLED (BT848_DMA_CTL_FIFO_EN | BT848_DMA_CTL_RISC_EN) 313 #define FIFO_RISC_DISABLED 0 314 315 #define ALL_INTS_DISABLED 0 316 #define ALL_INTS_CLEARED 0xffffffff 317 #define CAPTURE_OFF 0 318 319 #define BIT_SEVEN_HIGH (1<<7) 320 #define BIT_EIGHT_HIGH (1<<8) 321 322 #define I2C_BITS (BT848_INT_RACK | BT848_INT_I2CDONE) 323 #define TDEC_BITS (BT848_INT_FDSR | BT848_INT_FBUS) 324 325 326 327 static int oformat_meteor_to_bt( u_long format ); 328 329 static u_int pixfmt_swap_flags( int pixfmt ); 330 331 /* 332 * bt848 RISC programming routines. 333 */ 334 #ifdef BT848_DUMP 335 static int dump_bt848( bktr_ptr_t bktr ); 336 #endif 337 338 static void yuvpack_prog( bktr_ptr_t bktr, char i_flag, int cols, 339 int rows, int interlace ); 340 static void yuv422_prog( bktr_ptr_t bktr, char i_flag, int cols, 341 int rows, int interlace ); 342 static void yuv12_prog( bktr_ptr_t bktr, char i_flag, int cols, 343 int rows, int interlace ); 344 static void rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, 345 int rows, int interlace ); 346 static void rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, 347 int rows, int interlace ); 348 static void build_dma_prog( bktr_ptr_t bktr, char i_flag ); 349 350 static bool_t getline(bktr_reg_t *, int); 351 static bool_t notclipped(bktr_reg_t * , int , int); 352 static bool_t split(bktr_reg_t *, volatile uint32_t **, int, u_long, int, 353 volatile u_char ** , int ); 354 355 static void start_capture( bktr_ptr_t bktr, unsigned type ); 356 static void set_fps( bktr_ptr_t bktr, u_short fps ); 357 358 359 360 /* 361 * Remote Control Functions 362 */ 363 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote); 364 365 366 /* 367 * ioctls common to both video & tuner. 368 */ 369 static int common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg ); 370 371 372 #if !defined(BKTR_USE_FREEBSD_SMBUS) 373 /* 374 * i2c primitives for low level control of i2c bus. Added for MSP34xx control 375 */ 376 static void i2c_start( bktr_ptr_t bktr); 377 static void i2c_stop( bktr_ptr_t bktr); 378 static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data); 379 static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last ); 380 #endif 381 382 383 384 /* 385 * the common attach code, used by all OS versions. 386 */ 387 void 388 common_bktr_attach( bktr_ptr_t bktr, int unit, u_long pci_id, u_int rev ) 389 { 390 vm_offset_t buf = 0; 391 int need_to_allocate_memory = 1; 392 #ifdef BKTR_NEW_MSP34XX_DRIVER 393 int err; 394 #endif 395 396 /* If this is a module, check if there is any currently saved contiguous memory */ 397 #if defined(BKTR_FREEBSD_MODULE) 398 if (bktr_has_stored_addresses(unit) == 1) { 399 /* recover the addresses */ 400 bktr->dma_prog = bktr_retrieve_address(unit, BKTR_MEM_DMA_PROG); 401 bktr->odd_dma_prog = bktr_retrieve_address(unit, BKTR_MEM_ODD_DMA_PROG); 402 bktr->vbidata = bktr_retrieve_address(unit, BKTR_MEM_VBIDATA); 403 bktr->vbibuffer = bktr_retrieve_address(unit, BKTR_MEM_VBIBUFFER); 404 buf = bktr_retrieve_address(unit, BKTR_MEM_BUF); 405 need_to_allocate_memory = 0; 406 } 407 #endif 408 409 if (need_to_allocate_memory == 1) { 410 /* allocate space for dma program */ 411 bktr->dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC); 412 bktr->odd_dma_prog = get_bktr_mem(unit, DMA_PROG_ALLOC); 413 414 /* allocte space for the VBI buffer */ 415 bktr->vbidata = get_bktr_mem(unit, VBI_DATA_SIZE); 416 bktr->vbibuffer = get_bktr_mem(unit, VBI_BUFFER_SIZE); 417 418 /* allocate space for pixel buffer */ 419 if ( BROOKTREE_ALLOC ) 420 buf = get_bktr_mem(unit, BROOKTREE_ALLOC); 421 else 422 buf = 0; 423 } 424 425 #ifdef USE_VBIMUTEX 426 mtx_init(&bktr->vbimutex, "bktr vbi lock", NULL, MTX_DEF); 427 #endif 428 429 /* If this is a module, save the current contiguous memory */ 430 #if defined(BKTR_FREEBSD_MODULE) 431 bktr_store_address(unit, BKTR_MEM_DMA_PROG, bktr->dma_prog); 432 bktr_store_address(unit, BKTR_MEM_ODD_DMA_PROG, bktr->odd_dma_prog); 433 bktr_store_address(unit, BKTR_MEM_VBIDATA, bktr->vbidata); 434 bktr_store_address(unit, BKTR_MEM_VBIBUFFER, bktr->vbibuffer); 435 bktr_store_address(unit, BKTR_MEM_BUF, buf); 436 #endif 437 438 439 if ( bootverbose ) { 440 printf("%s: buffer size %d, addr %p\n", 441 bktr_name(bktr), BROOKTREE_ALLOC, 442 (void *)(uintptr_t)vtophys(buf)); 443 } 444 445 if ( buf != 0 ) { 446 bktr->bigbuf = buf; 447 bktr->alloc_pages = BROOKTREE_ALLOC_PAGES; 448 bzero((caddr_t) bktr->bigbuf, BROOKTREE_ALLOC); 449 } else { 450 bktr->alloc_pages = 0; 451 } 452 453 454 bktr->flags = METEOR_INITALIZED | METEOR_AUTOMODE | 455 METEOR_DEV0 | METEOR_RGB16; 456 bktr->dma_prog_loaded = FALSE; 457 bktr->cols = 640; 458 bktr->rows = 480; 459 bktr->frames = 1; /* one frame */ 460 bktr->format = METEOR_GEO_RGB16; 461 bktr->pixfmt = oformat_meteor_to_bt( bktr->format ); 462 bktr->pixfmt_compat = TRUE; 463 464 465 bktr->vbiinsert = 0; 466 bktr->vbistart = 0; 467 bktr->vbisize = 0; 468 bktr->vbiflags = 0; 469 470 471 /* using the pci device id and revision id */ 472 /* and determine the card type */ 473 if (PCI_VENDOR(pci_id) == PCI_VENDOR_BROOKTREE) 474 { 475 switch (PCI_PRODUCT(pci_id)) { 476 case PCI_PRODUCT_BROOKTREE_BT848: 477 if (rev == 0x12) 478 bktr->id = BROOKTREE_848A; 479 else 480 bktr->id = BROOKTREE_848; 481 break; 482 case PCI_PRODUCT_BROOKTREE_BT849: 483 bktr->id = BROOKTREE_849A; 484 break; 485 case PCI_PRODUCT_BROOKTREE_BT878: 486 bktr->id = BROOKTREE_878; 487 break; 488 case PCI_PRODUCT_BROOKTREE_BT879: 489 bktr->id = BROOKTREE_879; 490 break; 491 } 492 }; 493 494 bktr->clr_on_start = FALSE; 495 496 /* defaults for the tuner section of the card */ 497 bktr->tflags = TUNER_INITALIZED; 498 bktr->tuner.frequency = 0; 499 bktr->tuner.channel = 0; 500 bktr->tuner.chnlset = DEFAULT_CHNLSET; 501 bktr->tuner.afc = 0; 502 bktr->tuner.radio_mode = 0; 503 bktr->audio_mux_select = 0; 504 bktr->audio_mute_state = FALSE; 505 bktr->bt848_card = -1; 506 bktr->bt848_tuner = -1; 507 bktr->reverse_mute = -1; 508 bktr->slow_msp_audio = 0; 509 bktr->msp_use_mono_source = 0; 510 bktr->msp_source_selected = -1; 511 bktr->audio_mux_present = 1; 512 513 #ifdef BKTR_NEW_MSP34XX_DRIVER 514 /* get hint on short programming of the msp34xx, so we know */ 515 /* if the decision what thread to start should be overwritten */ 516 if ( (err = resource_int_value("bktr", unit, "mspsimple", 517 &(bktr->mspsimple)) ) != 0 ) 518 bktr->mspsimple = -1; /* fall back to default */ 519 #endif 520 521 probeCard( bktr, TRUE, unit ); 522 523 /* Initialise any MSP34xx or TDA98xx audio chips */ 524 init_audio_devices( bktr ); 525 526 #ifdef BKTR_NEW_MSP34XX_DRIVER 527 /* setup the kenrel thread */ 528 err = msp_attach( bktr ); 529 if ( err != 0 ) /* error doing kernel thread stuff, disable msp3400c */ 530 bktr->card.msp3400c = 0; 531 #endif 532 533 534 } 535 536 537 /* Copy the vbi lines from 'vbidata' into the circular buffer, 'vbibuffer'. 538 * The circular buffer holds 'n' fixed size data blocks. 539 * vbisize is the number of bytes in the circular buffer 540 * vbiread is the point we reading data out of the circular buffer 541 * vbiinsert is the point we insert data into the circular buffer 542 */ 543 static void vbidecode(bktr_ptr_t bktr) { 544 unsigned char *dest; 545 unsigned int *seq_dest; 546 547 /* Check if there is room in the buffer to insert the data. */ 548 if (bktr->vbisize + VBI_DATA_SIZE > VBI_BUFFER_SIZE) return; 549 550 /* Copy the VBI data into the next free slot in the buffer. */ 551 /* 'dest' is the point in vbibuffer where we want to insert new data */ 552 dest = (unsigned char *)bktr->vbibuffer + bktr->vbiinsert; 553 memcpy(dest, (unsigned char*)bktr->vbidata, VBI_DATA_SIZE); 554 555 /* Write the VBI sequence number to the end of the vbi data */ 556 /* This is used by the AleVT teletext program */ 557 seq_dest = (unsigned int *)((unsigned char *)bktr->vbibuffer 558 + bktr->vbiinsert 559 + (VBI_DATA_SIZE - sizeof(bktr->vbi_sequence_number))); 560 *seq_dest = bktr->vbi_sequence_number; 561 562 /* And increase the VBI sequence number */ 563 /* This can wrap around */ 564 bktr->vbi_sequence_number++; 565 566 567 /* Increment the vbiinsert pointer */ 568 /* This can wrap around */ 569 bktr->vbiinsert += VBI_DATA_SIZE; 570 bktr->vbiinsert = (bktr->vbiinsert % VBI_BUFFER_SIZE); 571 572 /* And increase the amount of vbi data in the buffer */ 573 bktr->vbisize = bktr->vbisize + VBI_DATA_SIZE; 574 575 } 576 577 578 /* 579 * the common interrupt handler. 580 * Returns a 0 or 1 depending on whether the interrupt has handled. 581 * In the OS specific section, bktr_intr() is defined which calls this 582 * common interrupt handler. 583 */ 584 int 585 common_bktr_intr( void *arg ) 586 { 587 bktr_ptr_t bktr; 588 u_long bktr_status; 589 u_char dstatus; 590 u_long field; 591 u_long w_field; 592 u_long req_field; 593 594 bktr = (bktr_ptr_t) arg; 595 596 /* 597 * check to see if any interrupts are unmasked on this device. If 598 * none are, then we likely got here by way of being on a PCI shared 599 * interrupt dispatch list. 600 */ 601 if (INL(bktr, BKTR_INT_MASK) == ALL_INTS_DISABLED) 602 return 0; /* bail out now, before we do something we 603 shouldn't */ 604 605 if (!(bktr->flags & METEOR_OPEN)) { 606 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 607 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 608 /* return; ?? */ 609 } 610 611 /* record and clear the INTerrupt status bits */ 612 bktr_status = INL(bktr, BKTR_INT_STAT); 613 OUTL(bktr, BKTR_INT_STAT, bktr_status & ~I2C_BITS); /* don't touch i2c */ 614 615 /* record and clear the device status register */ 616 dstatus = INB(bktr, BKTR_DSTATUS); 617 OUTB(bktr, BKTR_DSTATUS, 0x00); 618 619 #if defined( STATUS_SUM ) 620 /* add any new device status or INTerrupt status bits */ 621 status_sum |= (bktr_status & ~(BT848_INT_RSV0|BT848_INT_RSV1)); 622 status_sum |= ((dstatus & (BT848_DSTATUS_COF|BT848_DSTATUS_LOF)) << 6); 623 #endif /* STATUS_SUM */ 624 /* printf( "%s: STATUS %x %x %x \n", bktr_name(bktr), 625 dstatus, bktr_status, INL(bktr, BKTR_RISC_COUNT) ); 626 */ 627 628 629 /* if risc was disabled re-start process again */ 630 /* if there was one of the following errors re-start again */ 631 if ( !(bktr_status & BT848_INT_RISC_EN) || 632 ((bktr_status &(/* BT848_INT_FBUS | */ 633 /* BT848_INT_FTRGT | */ 634 /* BT848_INT_FDSR | */ 635 BT848_INT_PPERR | 636 BT848_INT_RIPERR | BT848_INT_PABORT | 637 BT848_INT_OCERR | BT848_INT_SCERR) ) != 0) 638 || ((INB(bktr, BKTR_TDEC) == 0) && (bktr_status & TDEC_BITS)) ) { 639 640 u_short tdec_save = INB(bktr, BKTR_TDEC); 641 642 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 643 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF); 644 645 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 646 647 /* Reset temporal decimation counter */ 648 OUTB(bktr, BKTR_TDEC, 0); 649 OUTB(bktr, BKTR_TDEC, tdec_save); 650 651 /* Reset to no-fields captured state */ 652 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) { 653 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 654 case METEOR_ONLY_ODD_FIELDS: 655 bktr->flags |= METEOR_WANT_ODD; 656 break; 657 case METEOR_ONLY_EVEN_FIELDS: 658 bktr->flags |= METEOR_WANT_EVEN; 659 break; 660 default: 661 bktr->flags |= METEOR_WANT_MASK; 662 break; 663 } 664 } 665 666 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); 667 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 668 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); 669 670 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT | 671 BT848_INT_RISCI | 672 BT848_INT_VSYNC | 673 BT848_INT_FMTCHG); 674 675 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl); 676 return 1; 677 } 678 679 /* If this is not a RISC program interrupt, return */ 680 if (!(bktr_status & BT848_INT_RISCI)) 681 return 0; 682 683 /** 684 printf( "%s: intr status %x %x %x\n", bktr_name(bktr), 685 bktr_status, dstatus, INL(bktr, BKTR_RISC_COUNT) ); 686 */ 687 688 689 /* 690 * Disable future interrupts if a capture mode is not selected. 691 * This can happen when we are in the process of closing or 692 * changing capture modes, otherwise it shouldn't happen. 693 */ 694 if (!(bktr->flags & METEOR_CAP_MASK)) 695 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF); 696 697 698 /* Determine which field generated this interrupt */ 699 field = ( bktr_status & BT848_INT_FIELD ) ? EVEN_F : ODD_F; 700 701 702 /* 703 * Process the VBI data if it is being captured. We do this once 704 * both Odd and Even VBI data is captured. Therefore we do this 705 * in the Even field interrupt handler. 706 */ 707 LOCK_VBI(bktr); 708 if ( (bktr->vbiflags & VBI_CAPTURE) 709 &&(bktr->vbiflags & VBI_OPEN) 710 &&(field==EVEN_F)) { 711 /* Put VBI data into circular buffer */ 712 vbidecode(bktr); 713 714 /* If someone is blocked on reading from /dev/vbi, wake them */ 715 if (bktr->vbi_read_blocked) { 716 bktr->vbi_read_blocked = FALSE; 717 wakeup(VBI_SLEEP); 718 } 719 720 /* If someone has a select() on /dev/vbi, inform them */ 721 if (bktr->vbi_select.si_pid) { 722 selwakeup(&bktr->vbi_select); 723 } 724 725 726 } 727 UNLOCK_VBI(bktr); 728 729 /* 730 * Register the completed field 731 * (For dual-field mode, require fields from the same frame) 732 */ 733 switch ( bktr->flags & METEOR_WANT_MASK ) { 734 case METEOR_WANT_ODD : w_field = ODD_F ; break; 735 case METEOR_WANT_EVEN : w_field = EVEN_F ; break; 736 default : w_field = (ODD_F|EVEN_F); break; 737 } 738 switch ( bktr->flags & METEOR_ONLY_FIELDS_MASK ) { 739 case METEOR_ONLY_ODD_FIELDS : req_field = ODD_F ; break; 740 case METEOR_ONLY_EVEN_FIELDS : req_field = EVEN_F ; break; 741 default : req_field = (ODD_F|EVEN_F); 742 break; 743 } 744 745 if (( field == EVEN_F ) && ( w_field == EVEN_F )) 746 bktr->flags &= ~METEOR_WANT_EVEN; 747 else if (( field == ODD_F ) && ( req_field == ODD_F ) && 748 ( w_field == ODD_F )) 749 bktr->flags &= ~METEOR_WANT_ODD; 750 else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) && 751 ( w_field == (ODD_F|EVEN_F) )) 752 bktr->flags &= ~METEOR_WANT_ODD; 753 else if (( field == ODD_F ) && ( req_field == (ODD_F|EVEN_F) ) && 754 ( w_field == ODD_F )) { 755 bktr->flags &= ~METEOR_WANT_ODD; 756 bktr->flags |= METEOR_WANT_EVEN; 757 } 758 else { 759 /* We're out of sync. Start over. */ 760 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) { 761 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 762 case METEOR_ONLY_ODD_FIELDS: 763 bktr->flags |= METEOR_WANT_ODD; 764 break; 765 case METEOR_ONLY_EVEN_FIELDS: 766 bktr->flags |= METEOR_WANT_EVEN; 767 break; 768 default: 769 bktr->flags |= METEOR_WANT_MASK; 770 break; 771 } 772 } 773 return 1; 774 } 775 776 /* 777 * If we have a complete frame. 778 */ 779 if (!(bktr->flags & METEOR_WANT_MASK)) { 780 bktr->frames_captured++; 781 /* 782 * post the completion time. 783 */ 784 if (bktr->flags & METEOR_WANT_TS) { 785 struct timeval *ts; 786 787 if ((u_int) bktr->alloc_pages * PAGE_SIZE 788 <= (bktr->frame_size + sizeof(struct timeval))) { 789 ts =(struct timeval *)bktr->bigbuf + 790 bktr->frame_size; 791 /* doesn't work in synch mode except 792 * for first frame */ 793 /* XXX */ 794 microtime(ts); 795 } 796 } 797 798 799 /* 800 * Wake up the user in single capture mode. 801 */ 802 if (bktr->flags & METEOR_SINGLE) { 803 804 /* stop dma */ 805 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 806 807 /* disable risc, leave fifo running */ 808 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 809 wakeup(BKTR_SLEEP); 810 } 811 812 /* 813 * If the user requested to be notified via signal, 814 * let them know the frame is complete. 815 */ 816 817 if (bktr->proc != NULL) { 818 PROC_LOCK(bktr->proc); 819 psignal( bktr->proc, bktr->signal); 820 PROC_UNLOCK(bktr->proc); 821 } 822 823 /* 824 * Reset the want flags if in continuous or 825 * synchronous capture mode. 826 */ 827 /* 828 * XXX NOTE (Luigi): 829 * currently we only support 3 capture modes: odd only, even only, 830 * odd+even interlaced (odd field first). A fourth mode (non interlaced, 831 * either even OR odd) could provide 60 (50 for PAL) pictures per 832 * second, but it would require this routine to toggle the desired frame 833 * each time, and one more different DMA program for the Bt848. 834 * As a consequence, this fourth mode is currently unsupported. 835 */ 836 837 if (bktr->flags & (METEOR_CONTIN | METEOR_SYNCAP)) { 838 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 839 case METEOR_ONLY_ODD_FIELDS: 840 bktr->flags |= METEOR_WANT_ODD; 841 break; 842 case METEOR_ONLY_EVEN_FIELDS: 843 bktr->flags |= METEOR_WANT_EVEN; 844 break; 845 default: 846 bktr->flags |= METEOR_WANT_MASK; 847 break; 848 } 849 } 850 } 851 852 return 1; 853 } 854 855 856 857 858 /* 859 * 860 */ 861 extern int bt848_format; /* used to set the default format, PAL or NTSC */ 862 int 863 video_open( bktr_ptr_t bktr ) 864 { 865 int frame_rate, video_format=0; 866 867 if (bktr->flags & METEOR_OPEN) /* device is busy */ 868 return( EBUSY ); 869 870 bktr->flags |= METEOR_OPEN; 871 872 #ifdef BT848_DUMP 873 dump_bt848( bt848 ); 874 #endif 875 876 bktr->clr_on_start = FALSE; 877 878 OUTB(bktr, BKTR_DSTATUS, 0x00); /* clear device status reg. */ 879 880 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 881 882 #if BKTR_SYSTEM_DEFAULT == BROOKTREE_PAL 883 video_format = 0; 884 #else 885 video_format = 1; 886 #endif 887 888 if (bt848_format == 0 ) 889 video_format = 0; 890 891 if (bt848_format == 1 ) 892 video_format = 1; 893 894 if (video_format == 1 ) { 895 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_NTSCM); 896 bktr->format_params = BT848_IFORM_F_NTSCM; 897 898 } else { 899 OUTB(bktr, BKTR_IFORM, BT848_IFORM_F_PALBDGHI); 900 bktr->format_params = BT848_IFORM_F_PALBDGHI; 901 902 } 903 904 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | format_params[bktr->format_params].iform_xtsel); 905 906 /* work around for new Hauppauge 878 cards */ 907 if ((bktr->card.card_id == CARD_HAUPPAUGE) && 908 (bktr->id==BROOKTREE_878 || bktr->id==BROOKTREE_879) ) 909 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3); 910 else 911 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1); 912 913 OUTB(bktr, BKTR_ADELAY, format_params[bktr->format_params].adelay); 914 OUTB(bktr, BKTR_BDELAY, format_params[bktr->format_params].bdelay); 915 frame_rate = format_params[bktr->format_params].frame_rate; 916 917 /* enable PLL mode using 28Mhz crystal for PAL/SECAM users */ 918 if (bktr->xtal_pll_mode == BT848_USE_PLL) { 919 OUTB(bktr, BKTR_TGCTRL, 0); 920 OUTB(bktr, BKTR_PLL_F_LO, 0xf9); 921 OUTB(bktr, BKTR_PLL_F_HI, 0xdc); 922 OUTB(bktr, BKTR_PLL_F_XCI, 0x8e); 923 } 924 925 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) | METEOR_DEV0; 926 927 bktr->max_clip_node = 0; 928 929 OUTB(bktr, BKTR_COLOR_CTL, BT848_COLOR_CTL_GAMMA | BT848_COLOR_CTL_RGB_DED); 930 931 OUTB(bktr, BKTR_E_HSCALE_LO, 170); 932 OUTB(bktr, BKTR_O_HSCALE_LO, 170); 933 934 OUTB(bktr, BKTR_E_DELAY_LO, 0x72); 935 OUTB(bktr, BKTR_O_DELAY_LO, 0x72); 936 OUTB(bktr, BKTR_E_SCLOOP, 0); 937 OUTB(bktr, BKTR_O_SCLOOP, 0); 938 939 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0); 940 OUTB(bktr, BKTR_VBI_PACK_DEL, 0); 941 942 bktr->fifo_errors = 0; 943 bktr->dma_errors = 0; 944 bktr->frames_captured = 0; 945 bktr->even_fields_captured = 0; 946 bktr->odd_fields_captured = 0; 947 bktr->proc = NULL; 948 set_fps(bktr, frame_rate); 949 bktr->video.addr = 0; 950 bktr->video.width = 0; 951 bktr->video.banksize = 0; 952 bktr->video.ramsize = 0; 953 bktr->pixfmt_compat = TRUE; 954 bktr->format = METEOR_GEO_RGB16; 955 bktr->pixfmt = oformat_meteor_to_bt( bktr->format ); 956 957 bktr->capture_area_enabled = FALSE; 958 959 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT); /* if you take this out triton 960 based motherboards will 961 operate unreliably */ 962 return( 0 ); 963 } 964 965 int 966 vbi_open( bktr_ptr_t bktr ) 967 { 968 969 LOCK_VBI(bktr); 970 971 if (bktr->vbiflags & VBI_OPEN) { /* device is busy */ 972 UNLOCK_VBI(bktr); 973 return( EBUSY ); 974 } 975 976 bktr->vbiflags |= VBI_OPEN; 977 978 /* reset the VBI circular buffer pointers and clear the buffers */ 979 bktr->vbiinsert = 0; 980 bktr->vbistart = 0; 981 bktr->vbisize = 0; 982 bktr->vbi_sequence_number = 0; 983 bktr->vbi_read_blocked = FALSE; 984 985 bzero((caddr_t) bktr->vbibuffer, VBI_BUFFER_SIZE); 986 bzero((caddr_t) bktr->vbidata, VBI_DATA_SIZE); 987 988 UNLOCK_VBI(bktr); 989 990 return( 0 ); 991 } 992 993 /* 994 * 995 */ 996 int 997 tuner_open( bktr_ptr_t bktr ) 998 { 999 if ( !(bktr->tflags & TUNER_INITALIZED) ) /* device not found */ 1000 return( ENXIO ); 1001 1002 if ( bktr->tflags & TUNER_OPEN ) /* already open */ 1003 return( 0 ); 1004 1005 bktr->tflags |= TUNER_OPEN; 1006 bktr->tuner.frequency = 0; 1007 bktr->tuner.channel = 0; 1008 bktr->tuner.chnlset = DEFAULT_CHNLSET; 1009 bktr->tuner.afc = 0; 1010 bktr->tuner.radio_mode = 0; 1011 1012 /* enable drivers on the GPIO port that control the MUXes */ 1013 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) | bktr->card.gpio_mux_bits); 1014 1015 /* unmute the audio stream */ 1016 set_audio( bktr, AUDIO_UNMUTE ); 1017 1018 /* Initialise any audio chips, eg MSP34xx or TDA98xx */ 1019 init_audio_devices( bktr ); 1020 1021 return( 0 ); 1022 } 1023 1024 1025 1026 1027 /* 1028 * 1029 */ 1030 int 1031 video_close( bktr_ptr_t bktr ) 1032 { 1033 bktr->flags &= ~(METEOR_OPEN | 1034 METEOR_SINGLE | 1035 METEOR_CAP_MASK | 1036 METEOR_WANT_MASK); 1037 1038 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 1039 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF); 1040 1041 bktr->dma_prog_loaded = FALSE; 1042 OUTB(bktr, BKTR_TDEC, 0); 1043 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 1044 1045 /** FIXME: is 0xf magic, wouldn't 0x00 work ??? */ 1046 OUTL(bktr, BKTR_SRESET, 0xf); 1047 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED); 1048 1049 return( 0 ); 1050 } 1051 1052 1053 /* 1054 * tuner close handle, 1055 * place holder for tuner specific operations on a close. 1056 */ 1057 int 1058 tuner_close( bktr_ptr_t bktr ) 1059 { 1060 bktr->tflags &= ~TUNER_OPEN; 1061 1062 /* mute the audio by switching the mux */ 1063 set_audio( bktr, AUDIO_MUTE ); 1064 1065 /* disable drivers on the GPIO port that control the MUXes */ 1066 OUTL(bktr, BKTR_GPIO_OUT_EN, INL(bktr, BKTR_GPIO_OUT_EN) & ~bktr->card.gpio_mux_bits); 1067 1068 return( 0 ); 1069 } 1070 1071 int 1072 vbi_close( bktr_ptr_t bktr ) 1073 { 1074 1075 LOCK_VBI(bktr); 1076 1077 bktr->vbiflags &= ~VBI_OPEN; 1078 1079 UNLOCK_VBI(bktr); 1080 1081 return( 0 ); 1082 } 1083 1084 /* 1085 * 1086 */ 1087 int 1088 video_read(bktr_ptr_t bktr, int unit, dev_t dev, struct uio *uio) 1089 { 1090 int status; 1091 int count; 1092 1093 1094 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */ 1095 return( ENOMEM ); 1096 1097 if (bktr->flags & METEOR_CAP_MASK) 1098 return( EIO ); /* already capturing */ 1099 1100 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl); 1101 1102 1103 count = bktr->rows * bktr->cols * 1104 pixfmt_table[ bktr->pixfmt ].public.Bpp; 1105 1106 if ((int) uio->uio_iov->iov_len < count) 1107 return( EINVAL ); 1108 1109 bktr->flags &= ~(METEOR_CAP_MASK | METEOR_WANT_MASK); 1110 1111 /* capture one frame */ 1112 start_capture(bktr, METEOR_SINGLE); 1113 /* wait for capture to complete */ 1114 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED); 1115 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 1116 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); 1117 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT | 1118 BT848_INT_RISCI | 1119 BT848_INT_VSYNC | 1120 BT848_INT_FMTCHG); 1121 1122 1123 status = tsleep(BKTR_SLEEP, BKTRPRI, "captur", 0); 1124 if (!status) /* successful capture */ 1125 status = uiomove((caddr_t)bktr->bigbuf, count, uio); 1126 else 1127 printf ("%s: read: tsleep error %d\n", 1128 bktr_name(bktr), status); 1129 1130 bktr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK); 1131 1132 return( status ); 1133 } 1134 1135 /* 1136 * Read VBI data from the vbi circular buffer 1137 * The buffer holds vbi data blocks which are the same size 1138 * vbiinsert is the position we will insert the next item into the buffer 1139 * vbistart is the actual position in the buffer we want to read from 1140 * vbisize is the exact number of bytes in the buffer left to read 1141 */ 1142 int 1143 vbi_read(bktr_ptr_t bktr, struct uio *uio, int ioflag) 1144 { 1145 int readsize, readsize2, start; 1146 int status; 1147 1148 /* 1149 * XXX - vbi_read() should be protected against being re-entered 1150 * while it is unlocked for the uiomove. 1151 */ 1152 LOCK_VBI(bktr); 1153 1154 while(bktr->vbisize == 0) { 1155 if (ioflag & IO_NDELAY) { 1156 status = EWOULDBLOCK; 1157 goto out; 1158 } 1159 1160 bktr->vbi_read_blocked = TRUE; 1161 #ifdef USE_VBIMUTEX 1162 if ((status = msleep(VBI_SLEEP, &bktr->vbimutex, VBIPRI, "vbi", 1163 0))) { 1164 goto out; 1165 } 1166 #else 1167 if ((status = tsleep(VBI_SLEEP, VBIPRI, "vbi", 0))) { 1168 goto out; 1169 } 1170 #endif 1171 } 1172 1173 /* Now we have some data to give to the user */ 1174 1175 /* We cannot read more bytes than there are in 1176 * the circular buffer 1177 */ 1178 readsize = (int)uio->uio_iov->iov_len; 1179 1180 if (readsize > bktr->vbisize) readsize = bktr->vbisize; 1181 1182 /* Check if we can read this number of bytes without having 1183 * to wrap around the circular buffer */ 1184 if((bktr->vbistart + readsize) >= VBI_BUFFER_SIZE) { 1185 /* We need to wrap around */ 1186 1187 readsize2 = VBI_BUFFER_SIZE - bktr->vbistart; 1188 start = bktr->vbistart; 1189 UNLOCK_VBI(bktr); 1190 status = uiomove((caddr_t)bktr->vbibuffer + start, readsize2, uio); 1191 if (status == 0) 1192 status = uiomove((caddr_t)bktr->vbibuffer, (readsize - readsize2), uio); 1193 } else { 1194 UNLOCK_VBI(bktr); 1195 /* We do not need to wrap around */ 1196 status = uiomove((caddr_t)bktr->vbibuffer + bktr->vbistart, readsize, uio); 1197 } 1198 1199 LOCK_VBI(bktr); 1200 1201 /* Update the number of bytes left to read */ 1202 bktr->vbisize -= readsize; 1203 1204 /* Update vbistart */ 1205 bktr->vbistart += readsize; 1206 bktr->vbistart = bktr->vbistart % VBI_BUFFER_SIZE; /* wrap around if needed */ 1207 1208 out: 1209 UNLOCK_VBI(bktr); 1210 1211 return( status ); 1212 1213 } 1214 1215 1216 1217 /* 1218 * video ioctls 1219 */ 1220 int 1221 video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td ) 1222 { 1223 volatile u_char c_temp; 1224 unsigned int temp; 1225 unsigned int temp_iform; 1226 unsigned int error; 1227 struct meteor_geomet *geo; 1228 struct meteor_counts *counts; 1229 struct meteor_video *video; 1230 struct bktr_capture_area *cap_area; 1231 vm_offset_t buf; 1232 int i; 1233 int sig; 1234 char char_temp; 1235 1236 switch ( cmd ) { 1237 1238 case BT848SCLIP: /* set clip region */ 1239 bktr->max_clip_node = 0; 1240 memcpy(&bktr->clip_list, arg, sizeof(bktr->clip_list)); 1241 1242 for (i = 0; i < BT848_MAX_CLIP_NODE; i++) { 1243 if (bktr->clip_list[i].y_min == 0 && 1244 bktr->clip_list[i].y_max == 0) 1245 break; 1246 } 1247 bktr->max_clip_node = i; 1248 1249 /* make sure that the list contains a valid clip secquence */ 1250 /* the clip rectangles should be sorted by x then by y as the 1251 second order sort key */ 1252 1253 /* clip rectangle list is terminated by y_min and y_max set to 0 */ 1254 1255 /* to disable clipping set y_min and y_max to 0 in the first 1256 clip rectangle . The first clip rectangle is clip_list[0]. 1257 */ 1258 1259 1260 1261 if (bktr->max_clip_node == 0 && 1262 (bktr->clip_list[0].y_min != 0 && 1263 bktr->clip_list[0].y_max != 0)) { 1264 return EINVAL; 1265 } 1266 1267 for (i = 0; i < BT848_MAX_CLIP_NODE - 1 ; i++) { 1268 if (bktr->clip_list[i].y_min == 0 && 1269 bktr->clip_list[i].y_max == 0) { 1270 break; 1271 } 1272 if ( bktr->clip_list[i+1].y_min != 0 && 1273 bktr->clip_list[i+1].y_max != 0 && 1274 bktr->clip_list[i].x_min > bktr->clip_list[i+1].x_min ) { 1275 1276 bktr->max_clip_node = 0; 1277 return (EINVAL); 1278 1279 } 1280 1281 if (bktr->clip_list[i].x_min >= bktr->clip_list[i].x_max || 1282 bktr->clip_list[i].y_min >= bktr->clip_list[i].y_max || 1283 bktr->clip_list[i].x_min < 0 || 1284 bktr->clip_list[i].x_max < 0 || 1285 bktr->clip_list[i].y_min < 0 || 1286 bktr->clip_list[i].y_max < 0 ) { 1287 bktr->max_clip_node = 0; 1288 return (EINVAL); 1289 } 1290 } 1291 1292 bktr->dma_prog_loaded = FALSE; 1293 1294 break; 1295 1296 case METEORSTATUS: /* get Bt848 status */ 1297 c_temp = INB(bktr, BKTR_DSTATUS); 1298 temp = 0; 1299 if (!(c_temp & 0x40)) temp |= METEOR_STATUS_HCLK; 1300 if (!(c_temp & 0x10)) temp |= METEOR_STATUS_FIDT; 1301 *(u_short *)arg = temp; 1302 break; 1303 1304 case BT848SFMT: /* set input format */ 1305 temp = *(unsigned long*)arg & BT848_IFORM_FORMAT; 1306 temp_iform = INB(bktr, BKTR_IFORM); 1307 temp_iform &= ~BT848_IFORM_FORMAT; 1308 temp_iform &= ~BT848_IFORM_XTSEL; 1309 OUTB(bktr, BKTR_IFORM, (temp_iform | temp | format_params[temp].iform_xtsel)); 1310 switch( temp ) { 1311 case BT848_IFORM_F_AUTO: 1312 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1313 METEOR_AUTOMODE; 1314 break; 1315 1316 case BT848_IFORM_F_NTSCM: 1317 case BT848_IFORM_F_NTSCJ: 1318 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1319 METEOR_NTSC; 1320 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay); 1321 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay); 1322 bktr->format_params = temp; 1323 break; 1324 1325 case BT848_IFORM_F_PALBDGHI: 1326 case BT848_IFORM_F_PALN: 1327 case BT848_IFORM_F_SECAM: 1328 case BT848_IFORM_F_RSVD: 1329 case BT848_IFORM_F_PALM: 1330 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1331 METEOR_PAL; 1332 OUTB(bktr, BKTR_ADELAY, format_params[temp].adelay); 1333 OUTB(bktr, BKTR_BDELAY, format_params[temp].bdelay); 1334 bktr->format_params = temp; 1335 break; 1336 1337 } 1338 bktr->dma_prog_loaded = FALSE; 1339 break; 1340 1341 case METEORSFMT: /* set input format */ 1342 temp_iform = INB(bktr, BKTR_IFORM); 1343 temp_iform &= ~BT848_IFORM_FORMAT; 1344 temp_iform &= ~BT848_IFORM_XTSEL; 1345 switch(*(unsigned long *)arg & METEOR_FORM_MASK ) { 1346 case 0: /* default */ 1347 case METEOR_FMT_NTSC: 1348 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1349 METEOR_NTSC; 1350 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_NTSCM | 1351 format_params[BT848_IFORM_F_NTSCM].iform_xtsel); 1352 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_NTSCM].adelay); 1353 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_NTSCM].bdelay); 1354 bktr->format_params = BT848_IFORM_F_NTSCM; 1355 break; 1356 1357 case METEOR_FMT_PAL: 1358 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1359 METEOR_PAL; 1360 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_PALBDGHI | 1361 format_params[BT848_IFORM_F_PALBDGHI].iform_xtsel); 1362 OUTB(bktr, BKTR_ADELAY, format_params[BT848_IFORM_F_PALBDGHI].adelay); 1363 OUTB(bktr, BKTR_BDELAY, format_params[BT848_IFORM_F_PALBDGHI].bdelay); 1364 bktr->format_params = BT848_IFORM_F_PALBDGHI; 1365 break; 1366 1367 case METEOR_FMT_AUTOMODE: 1368 bktr->flags = (bktr->flags & ~METEOR_FORM_MASK) | 1369 METEOR_AUTOMODE; 1370 OUTB(bktr, BKTR_IFORM, temp_iform | BT848_IFORM_F_AUTO | 1371 format_params[BT848_IFORM_F_AUTO].iform_xtsel); 1372 break; 1373 1374 default: 1375 return( EINVAL ); 1376 } 1377 bktr->dma_prog_loaded = FALSE; 1378 break; 1379 1380 case METEORGFMT: /* get input format */ 1381 *(u_long *)arg = bktr->flags & METEOR_FORM_MASK; 1382 break; 1383 1384 1385 case BT848GFMT: /* get input format */ 1386 *(u_long *)arg = INB(bktr, BKTR_IFORM) & BT848_IFORM_FORMAT; 1387 break; 1388 1389 case METEORSCOUNT: /* (re)set error counts */ 1390 counts = (struct meteor_counts *) arg; 1391 bktr->fifo_errors = counts->fifo_errors; 1392 bktr->dma_errors = counts->dma_errors; 1393 bktr->frames_captured = counts->frames_captured; 1394 bktr->even_fields_captured = counts->even_fields_captured; 1395 bktr->odd_fields_captured = counts->odd_fields_captured; 1396 break; 1397 1398 case METEORGCOUNT: /* get error counts */ 1399 counts = (struct meteor_counts *) arg; 1400 counts->fifo_errors = bktr->fifo_errors; 1401 counts->dma_errors = bktr->dma_errors; 1402 counts->frames_captured = bktr->frames_captured; 1403 counts->even_fields_captured = bktr->even_fields_captured; 1404 counts->odd_fields_captured = bktr->odd_fields_captured; 1405 break; 1406 1407 case METEORGVIDEO: 1408 video = (struct meteor_video *)arg; 1409 video->addr = bktr->video.addr; 1410 video->width = bktr->video.width; 1411 video->banksize = bktr->video.banksize; 1412 video->ramsize = bktr->video.ramsize; 1413 break; 1414 1415 case METEORSVIDEO: 1416 video = (struct meteor_video *)arg; 1417 bktr->video.addr = video->addr; 1418 bktr->video.width = video->width; 1419 bktr->video.banksize = video->banksize; 1420 bktr->video.ramsize = video->ramsize; 1421 break; 1422 1423 case METEORSFPS: 1424 set_fps(bktr, *(u_short *)arg); 1425 break; 1426 1427 case METEORGFPS: 1428 *(u_short *)arg = bktr->fps; 1429 break; 1430 1431 case METEORSHUE: /* set hue */ 1432 OUTB(bktr, BKTR_HUE, (*(u_char *) arg) & 0xff); 1433 break; 1434 1435 case METEORGHUE: /* get hue */ 1436 *(u_char *)arg = INB(bktr, BKTR_HUE); 1437 break; 1438 1439 case METEORSBRIG: /* set brightness */ 1440 char_temp = ( *(u_char *)arg & 0xff) - 128; 1441 OUTB(bktr, BKTR_BRIGHT, char_temp); 1442 1443 break; 1444 1445 case METEORGBRIG: /* get brightness */ 1446 *(u_char *)arg = INB(bktr, BKTR_BRIGHT); 1447 break; 1448 1449 case METEORSCSAT: /* set chroma saturation */ 1450 temp = (int)*(u_char *)arg; 1451 1452 OUTB(bktr, BKTR_SAT_U_LO, (temp << 1) & 0xff); 1453 OUTB(bktr, BKTR_SAT_V_LO, (temp << 1) & 0xff); 1454 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) 1455 & ~(BT848_E_CONTROL_SAT_U_MSB 1456 | BT848_E_CONTROL_SAT_V_MSB)); 1457 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) 1458 & ~(BT848_O_CONTROL_SAT_U_MSB | 1459 BT848_O_CONTROL_SAT_V_MSB)); 1460 1461 if ( temp & BIT_SEVEN_HIGH ) { 1462 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) 1463 | (BT848_E_CONTROL_SAT_U_MSB 1464 | BT848_E_CONTROL_SAT_V_MSB)); 1465 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) 1466 | (BT848_O_CONTROL_SAT_U_MSB 1467 | BT848_O_CONTROL_SAT_V_MSB)); 1468 } 1469 break; 1470 1471 case METEORGCSAT: /* get chroma saturation */ 1472 temp = (INB(bktr, BKTR_SAT_V_LO) >> 1) & 0xff; 1473 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB ) 1474 temp |= BIT_SEVEN_HIGH; 1475 *(u_char *)arg = (u_char)temp; 1476 break; 1477 1478 case METEORSCONT: /* set contrast */ 1479 temp = (int)*(u_char *)arg & 0xff; 1480 temp <<= 1; 1481 OUTB(bktr, BKTR_CONTRAST_LO, temp & 0xff); 1482 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_CON_MSB); 1483 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_CON_MSB); 1484 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | 1485 (((temp & 0x100) >> 6 ) & BT848_E_CONTROL_CON_MSB)); 1486 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | 1487 (((temp & 0x100) >> 6 ) & BT848_O_CONTROL_CON_MSB)); 1488 break; 1489 1490 case METEORGCONT: /* get contrast */ 1491 temp = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff; 1492 temp |= ((int)INB(bktr, BKTR_O_CONTROL) & 0x04) << 6; 1493 *(u_char *)arg = (u_char)((temp >> 1) & 0xff); 1494 break; 1495 1496 case BT848SCBUF: /* set Clear-Buffer-on-start flag */ 1497 bktr->clr_on_start = (*(int *)arg != 0); 1498 break; 1499 1500 case BT848GCBUF: /* get Clear-Buffer-on-start flag */ 1501 *(int *)arg = (int) bktr->clr_on_start; 1502 break; 1503 1504 case METEORSSIGNAL: 1505 sig = *(int *)arg; 1506 /* Historically, applications used METEOR_SIG_MODE_MASK 1507 * to reset signal delivery. 1508 */ 1509 if (sig == METEOR_SIG_MODE_MASK) 1510 sig = 0; 1511 if (sig < 0 || sig > _SIG_MAXSIG) 1512 return (EINVAL); 1513 bktr->signal = sig; 1514 bktr->proc = sig ? td->td_proc : NULL; 1515 break; 1516 1517 case METEORGSIGNAL: 1518 *(int *)arg = bktr->signal; 1519 break; 1520 1521 case METEORCAPTUR: 1522 temp = bktr->flags; 1523 switch (*(int *) arg) { 1524 case METEOR_CAP_SINGLE: 1525 1526 if (bktr->bigbuf==0) /* no frame buffer allocated */ 1527 return( ENOMEM ); 1528 /* already capturing */ 1529 if (temp & METEOR_CAP_MASK) 1530 return( EIO ); 1531 1532 1533 1534 start_capture(bktr, METEOR_SINGLE); 1535 1536 /* wait for capture to complete */ 1537 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED); 1538 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 1539 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); 1540 1541 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT | 1542 BT848_INT_RISCI | 1543 BT848_INT_VSYNC | 1544 BT848_INT_FMTCHG); 1545 1546 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl); 1547 error = tsleep(BKTR_SLEEP, BKTRPRI, "captur", hz); 1548 if (error && (error != ERESTART)) { 1549 /* Here if we didn't get complete frame */ 1550 #ifdef DIAGNOSTIC 1551 printf( "%s: ioctl: tsleep error %d %x\n", 1552 bktr_name(bktr), error, 1553 INL(bktr, BKTR_RISC_COUNT)); 1554 #endif 1555 1556 /* stop dma */ 1557 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 1558 1559 /* disable risc, leave fifo running */ 1560 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 1561 } 1562 1563 bktr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK); 1564 /* FIXME: should we set bt848->int_stat ??? */ 1565 break; 1566 1567 case METEOR_CAP_CONTINOUS: 1568 if (bktr->bigbuf==0) /* no frame buffer allocated */ 1569 return( ENOMEM ); 1570 /* already capturing */ 1571 if (temp & METEOR_CAP_MASK) 1572 return( EIO ); 1573 1574 1575 start_capture(bktr, METEOR_CONTIN); 1576 1577 /* Clear the interrypt status register */ 1578 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT)); 1579 1580 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 1581 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); 1582 OUTB(bktr, BKTR_CAP_CTL, bktr->bktr_cap_ctl); 1583 1584 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT | 1585 BT848_INT_RISCI | 1586 BT848_INT_VSYNC | 1587 BT848_INT_FMTCHG); 1588 #ifdef BT848_DUMP 1589 dump_bt848( bt848 ); 1590 #endif 1591 break; 1592 1593 case METEOR_CAP_STOP_CONT: 1594 if (bktr->flags & METEOR_CONTIN) { 1595 /* turn off capture */ 1596 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 1597 OUTB(bktr, BKTR_CAP_CTL, CAPTURE_OFF); 1598 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 1599 bktr->flags &= 1600 ~(METEOR_CONTIN | METEOR_WANT_MASK); 1601 1602 } 1603 } 1604 break; 1605 1606 case METEORSETGEO: 1607 /* can't change parameters while capturing */ 1608 if (bktr->flags & METEOR_CAP_MASK) 1609 return( EBUSY ); 1610 1611 1612 geo = (struct meteor_geomet *) arg; 1613 1614 error = 0; 1615 /* Either even or odd, if even & odd, then these a zero */ 1616 if ((geo->oformat & METEOR_GEO_ODD_ONLY) && 1617 (geo->oformat & METEOR_GEO_EVEN_ONLY)) { 1618 printf( "%s: ioctl: Geometry odd or even only.\n", 1619 bktr_name(bktr)); 1620 return( EINVAL ); 1621 } 1622 1623 /* set/clear even/odd flags */ 1624 if (geo->oformat & METEOR_GEO_ODD_ONLY) 1625 bktr->flags |= METEOR_ONLY_ODD_FIELDS; 1626 else 1627 bktr->flags &= ~METEOR_ONLY_ODD_FIELDS; 1628 if (geo->oformat & METEOR_GEO_EVEN_ONLY) 1629 bktr->flags |= METEOR_ONLY_EVEN_FIELDS; 1630 else 1631 bktr->flags &= ~METEOR_ONLY_EVEN_FIELDS; 1632 1633 if (geo->columns <= 0) { 1634 printf( 1635 "%s: ioctl: %d: columns must be greater than zero.\n", 1636 bktr_name(bktr), geo->columns); 1637 error = EINVAL; 1638 } 1639 else if ((geo->columns & 0x3fe) != geo->columns) { 1640 printf( 1641 "%s: ioctl: %d: columns too large or not even.\n", 1642 bktr_name(bktr), geo->columns); 1643 error = EINVAL; 1644 } 1645 1646 if (geo->rows <= 0) { 1647 printf( 1648 "%s: ioctl: %d: rows must be greater than zero.\n", 1649 bktr_name(bktr), geo->rows); 1650 error = EINVAL; 1651 } 1652 else if (((geo->rows & 0x7fe) != geo->rows) || 1653 ((geo->oformat & METEOR_GEO_FIELD_MASK) && 1654 ((geo->rows & 0x3fe) != geo->rows)) ) { 1655 printf( 1656 "%s: ioctl: %d: rows too large or not even.\n", 1657 bktr_name(bktr), geo->rows); 1658 error = EINVAL; 1659 } 1660 1661 if (geo->frames > 32) { 1662 printf("%s: ioctl: too many frames.\n", 1663 bktr_name(bktr)); 1664 1665 error = EINVAL; 1666 } 1667 1668 if (error) 1669 return( error ); 1670 1671 bktr->dma_prog_loaded = FALSE; 1672 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 1673 1674 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 1675 1676 if ((temp=(geo->rows * geo->columns * geo->frames * 2))) { 1677 if (geo->oformat & METEOR_GEO_RGB24) temp = temp * 2; 1678 1679 /* meteor_mem structure for SYNC Capture */ 1680 if (geo->frames > 1) temp += PAGE_SIZE; 1681 1682 temp = btoc(temp); 1683 if ((int) temp > bktr->alloc_pages 1684 && bktr->video.addr == 0) { 1685 1686 buf = get_bktr_mem(unit, temp*PAGE_SIZE); 1687 if (buf != 0) { 1688 kmem_free(kernel_map, bktr->bigbuf, 1689 (bktr->alloc_pages * PAGE_SIZE)); 1690 1691 bktr->bigbuf = buf; 1692 bktr->alloc_pages = temp; 1693 if (bootverbose) 1694 printf( 1695 "%s: ioctl: Allocating %d bytes\n", 1696 bktr_name(bktr), temp*PAGE_SIZE); 1697 } 1698 else 1699 error = ENOMEM; 1700 } 1701 } 1702 1703 if (error) 1704 return error; 1705 1706 bktr->rows = geo->rows; 1707 bktr->cols = geo->columns; 1708 bktr->frames = geo->frames; 1709 1710 /* Pixel format (if in meteor pixfmt compatibility mode) */ 1711 if ( bktr->pixfmt_compat ) { 1712 bktr->format = METEOR_GEO_YUV_422; 1713 switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) { 1714 case 0: /* default */ 1715 case METEOR_GEO_RGB16: 1716 bktr->format = METEOR_GEO_RGB16; 1717 break; 1718 case METEOR_GEO_RGB24: 1719 bktr->format = METEOR_GEO_RGB24; 1720 break; 1721 case METEOR_GEO_YUV_422: 1722 bktr->format = METEOR_GEO_YUV_422; 1723 if (geo->oformat & METEOR_GEO_YUV_12) 1724 bktr->format = METEOR_GEO_YUV_12; 1725 break; 1726 case METEOR_GEO_YUV_PACKED: 1727 bktr->format = METEOR_GEO_YUV_PACKED; 1728 break; 1729 } 1730 bktr->pixfmt = oformat_meteor_to_bt( bktr->format ); 1731 } 1732 1733 if (bktr->flags & METEOR_CAP_MASK) { 1734 1735 if (bktr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) { 1736 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 1737 case METEOR_ONLY_ODD_FIELDS: 1738 bktr->flags |= METEOR_WANT_ODD; 1739 break; 1740 case METEOR_ONLY_EVEN_FIELDS: 1741 bktr->flags |= METEOR_WANT_EVEN; 1742 break; 1743 default: 1744 bktr->flags |= METEOR_WANT_MASK; 1745 break; 1746 } 1747 1748 start_capture(bktr, METEOR_CONTIN); 1749 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT)); 1750 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_ENABLED); 1751 OUTW(bktr, BKTR_GPIO_DMA_CTL, bktr->capcontrol); 1752 OUTL(bktr, BKTR_INT_MASK, BT848_INT_MYSTERYBIT | 1753 BT848_INT_VSYNC | 1754 BT848_INT_FMTCHG); 1755 } 1756 } 1757 break; 1758 /* end of METEORSETGEO */ 1759 1760 /* FIXME. The Capture Area currently has the following restrictions: 1761 GENERAL 1762 y_offset may need to be even in interlaced modes 1763 RGB24 - Interlaced mode 1764 x_size must be greater than or equal to 1.666*METEORSETGEO width (cols) 1765 y_size must be greater than or equal to METEORSETGEO height (rows) 1766 RGB24 - Even Only (or Odd Only) mode 1767 x_size must be greater than or equal to 1.666*METEORSETGEO width (cols) 1768 y_size must be greater than or equal to 2*METEORSETGEO height (rows) 1769 YUV12 - Interlaced mode 1770 x_size must be greater than or equal to METEORSETGEO width (cols) 1771 y_size must be greater than or equal to METEORSETGEO height (rows) 1772 YUV12 - Even Only (or Odd Only) mode 1773 x_size must be greater than or equal to METEORSETGEO width (cols) 1774 y_size must be greater than or equal to 2*METEORSETGEO height (rows) 1775 */ 1776 1777 case BT848_SCAPAREA: /* set capture area of each video frame */ 1778 /* can't change parameters while capturing */ 1779 if (bktr->flags & METEOR_CAP_MASK) 1780 return( EBUSY ); 1781 1782 cap_area = (struct bktr_capture_area *) arg; 1783 bktr->capture_area_x_offset = cap_area->x_offset; 1784 bktr->capture_area_y_offset = cap_area->y_offset; 1785 bktr->capture_area_x_size = cap_area->x_size; 1786 bktr->capture_area_y_size = cap_area->y_size; 1787 bktr->capture_area_enabled = TRUE; 1788 1789 bktr->dma_prog_loaded = FALSE; 1790 break; 1791 1792 case BT848_GCAPAREA: /* get capture area of each video frame */ 1793 cap_area = (struct bktr_capture_area *) arg; 1794 if (bktr->capture_area_enabled == FALSE) { 1795 cap_area->x_offset = 0; 1796 cap_area->y_offset = 0; 1797 cap_area->x_size = format_params[ 1798 bktr->format_params].scaled_hactive; 1799 cap_area->y_size = format_params[ 1800 bktr->format_params].vactive; 1801 } else { 1802 cap_area->x_offset = bktr->capture_area_x_offset; 1803 cap_area->y_offset = bktr->capture_area_y_offset; 1804 cap_area->x_size = bktr->capture_area_x_size; 1805 cap_area->y_size = bktr->capture_area_y_size; 1806 } 1807 break; 1808 1809 default: 1810 return common_ioctl( bktr, cmd, arg ); 1811 } 1812 1813 return( 0 ); 1814 } 1815 1816 /* 1817 * tuner ioctls 1818 */ 1819 int 1820 tuner_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_t cmd, caddr_t arg, struct thread* td ) 1821 { 1822 int tmp_int; 1823 unsigned int temp, temp1; 1824 int offset; 1825 int count; 1826 u_char *buf; 1827 u_long par; 1828 u_char write; 1829 int i2c_addr; 1830 int i2c_port; 1831 u_long data; 1832 1833 switch ( cmd ) { 1834 1835 case REMOTE_GETKEY: 1836 /* Read the last key pressed by the Remote Control */ 1837 if (bktr->remote_control == 0) return (EINVAL); 1838 remote_read(bktr, (struct bktr_remote *)arg); 1839 break; 1840 1841 #if defined( TUNER_AFC ) 1842 case TVTUNER_SETAFC: 1843 bktr->tuner.afc = (*(int *)arg != 0); 1844 break; 1845 1846 case TVTUNER_GETAFC: 1847 *(int *)arg = bktr->tuner.afc; 1848 /* XXX Perhaps use another bit to indicate AFC success? */ 1849 break; 1850 #endif /* TUNER_AFC */ 1851 1852 case TVTUNER_SETCHNL: 1853 temp_mute( bktr, TRUE ); 1854 temp = tv_channel( bktr, (int)*(unsigned long *)arg ); 1855 if ( temp < 0 ) { 1856 temp_mute( bktr, FALSE ); 1857 return( EINVAL ); 1858 } 1859 *(unsigned long *)arg = temp; 1860 1861 /* after every channel change, we must restart the MSP34xx */ 1862 /* audio chip to reselect NICAM STEREO or MONO audio */ 1863 if ( bktr->card.msp3400c ) 1864 msp_autodetect( bktr ); 1865 1866 /* after every channel change, we must restart the DPL35xx */ 1867 if ( bktr->card.dpl3518a ) 1868 dpl_autodetect( bktr ); 1869 1870 temp_mute( bktr, FALSE ); 1871 break; 1872 1873 case TVTUNER_GETCHNL: 1874 *(unsigned long *)arg = bktr->tuner.channel; 1875 break; 1876 1877 case TVTUNER_SETTYPE: 1878 temp = *(unsigned long *)arg; 1879 if ( (temp < CHNLSET_MIN) || (temp > CHNLSET_MAX) ) 1880 return( EINVAL ); 1881 bktr->tuner.chnlset = temp; 1882 break; 1883 1884 case TVTUNER_GETTYPE: 1885 *(unsigned long *)arg = bktr->tuner.chnlset; 1886 break; 1887 1888 case TVTUNER_GETSTATUS: 1889 temp = get_tuner_status( bktr ); 1890 *(unsigned long *)arg = temp & 0xff; 1891 break; 1892 1893 case TVTUNER_SETFREQ: 1894 temp_mute( bktr, TRUE ); 1895 temp = tv_freq( bktr, (int)*(unsigned long *)arg, TV_FREQUENCY); 1896 temp_mute( bktr, FALSE ); 1897 if ( temp < 0 ) { 1898 temp_mute( bktr, FALSE ); 1899 return( EINVAL ); 1900 } 1901 *(unsigned long *)arg = temp; 1902 1903 /* after every channel change, we must restart the MSP34xx */ 1904 /* audio chip to reselect NICAM STEREO or MONO audio */ 1905 if ( bktr->card.msp3400c ) 1906 msp_autodetect( bktr ); 1907 1908 /* after every channel change, we must restart the DPL35xx */ 1909 if ( bktr->card.dpl3518a ) 1910 dpl_autodetect( bktr ); 1911 1912 temp_mute( bktr, FALSE ); 1913 break; 1914 1915 case TVTUNER_GETFREQ: 1916 *(unsigned long *)arg = bktr->tuner.frequency; 1917 break; 1918 1919 case TVTUNER_GETCHNLSET: 1920 return tuner_getchnlset((struct bktr_chnlset *)arg); 1921 1922 case BT848_SAUDIO: /* set audio channel */ 1923 if ( set_audio( bktr, *(int*)arg ) < 0 ) 1924 return( EIO ); 1925 break; 1926 1927 /* hue is a 2's compliment number, -90' to +89.3' in 0.7' steps */ 1928 case BT848_SHUE: /* set hue */ 1929 OUTB(bktr, BKTR_HUE, (u_char)(*(int*)arg & 0xff)); 1930 break; 1931 1932 case BT848_GHUE: /* get hue */ 1933 *(int*)arg = (signed char)(INB(bktr, BKTR_HUE) & 0xff); 1934 break; 1935 1936 /* brightness is a 2's compliment #, -50 to +%49.6% in 0.39% steps */ 1937 case BT848_SBRIG: /* set brightness */ 1938 OUTB(bktr, BKTR_BRIGHT, (u_char)(*(int *)arg & 0xff)); 1939 break; 1940 1941 case BT848_GBRIG: /* get brightness */ 1942 *(int *)arg = (signed char)(INB(bktr, BKTR_BRIGHT) & 0xff); 1943 break; 1944 1945 /* */ 1946 case BT848_SCSAT: /* set chroma saturation */ 1947 tmp_int = *(int*)arg; 1948 1949 temp = INB(bktr, BKTR_E_CONTROL); 1950 temp1 = INB(bktr, BKTR_O_CONTROL); 1951 if ( tmp_int & BIT_EIGHT_HIGH ) { 1952 temp |= (BT848_E_CONTROL_SAT_U_MSB | 1953 BT848_E_CONTROL_SAT_V_MSB); 1954 temp1 |= (BT848_O_CONTROL_SAT_U_MSB | 1955 BT848_O_CONTROL_SAT_V_MSB); 1956 } 1957 else { 1958 temp &= ~(BT848_E_CONTROL_SAT_U_MSB | 1959 BT848_E_CONTROL_SAT_V_MSB); 1960 temp1 &= ~(BT848_O_CONTROL_SAT_U_MSB | 1961 BT848_O_CONTROL_SAT_V_MSB); 1962 } 1963 1964 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff)); 1965 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff)); 1966 OUTB(bktr, BKTR_E_CONTROL, temp); 1967 OUTB(bktr, BKTR_O_CONTROL, temp1); 1968 break; 1969 1970 case BT848_GCSAT: /* get chroma saturation */ 1971 tmp_int = (int)(INB(bktr, BKTR_SAT_V_LO) & 0xff); 1972 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB ) 1973 tmp_int |= BIT_EIGHT_HIGH; 1974 *(int*)arg = tmp_int; 1975 break; 1976 1977 /* */ 1978 case BT848_SVSAT: /* set chroma V saturation */ 1979 tmp_int = *(int*)arg; 1980 1981 temp = INB(bktr, BKTR_E_CONTROL); 1982 temp1 = INB(bktr, BKTR_O_CONTROL); 1983 if ( tmp_int & BIT_EIGHT_HIGH) { 1984 temp |= BT848_E_CONTROL_SAT_V_MSB; 1985 temp1 |= BT848_O_CONTROL_SAT_V_MSB; 1986 } 1987 else { 1988 temp &= ~BT848_E_CONTROL_SAT_V_MSB; 1989 temp1 &= ~BT848_O_CONTROL_SAT_V_MSB; 1990 } 1991 1992 OUTB(bktr, BKTR_SAT_V_LO, (u_char)(tmp_int & 0xff)); 1993 OUTB(bktr, BKTR_E_CONTROL, temp); 1994 OUTB(bktr, BKTR_O_CONTROL, temp1); 1995 break; 1996 1997 case BT848_GVSAT: /* get chroma V saturation */ 1998 tmp_int = (int)INB(bktr, BKTR_SAT_V_LO) & 0xff; 1999 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_V_MSB ) 2000 tmp_int |= BIT_EIGHT_HIGH; 2001 *(int*)arg = tmp_int; 2002 break; 2003 2004 /* */ 2005 case BT848_SUSAT: /* set chroma U saturation */ 2006 tmp_int = *(int*)arg; 2007 2008 temp = INB(bktr, BKTR_E_CONTROL); 2009 temp1 = INB(bktr, BKTR_O_CONTROL); 2010 if ( tmp_int & BIT_EIGHT_HIGH ) { 2011 temp |= BT848_E_CONTROL_SAT_U_MSB; 2012 temp1 |= BT848_O_CONTROL_SAT_U_MSB; 2013 } 2014 else { 2015 temp &= ~BT848_E_CONTROL_SAT_U_MSB; 2016 temp1 &= ~BT848_O_CONTROL_SAT_U_MSB; 2017 } 2018 2019 OUTB(bktr, BKTR_SAT_U_LO, (u_char)(tmp_int & 0xff)); 2020 OUTB(bktr, BKTR_E_CONTROL, temp); 2021 OUTB(bktr, BKTR_O_CONTROL, temp1); 2022 break; 2023 2024 case BT848_GUSAT: /* get chroma U saturation */ 2025 tmp_int = (int)INB(bktr, BKTR_SAT_U_LO) & 0xff; 2026 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_SAT_U_MSB ) 2027 tmp_int |= BIT_EIGHT_HIGH; 2028 *(int*)arg = tmp_int; 2029 break; 2030 2031 /* lr 970528 luma notch etc - 3 high bits of e_control/o_control */ 2032 2033 case BT848_SLNOTCH: /* set luma notch */ 2034 tmp_int = (*(int *)arg & 0x7) << 5 ; 2035 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~0xe0); 2036 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~0xe0); 2037 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | tmp_int); 2038 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | tmp_int); 2039 break; 2040 2041 case BT848_GLNOTCH: /* get luma notch */ 2042 *(int *)arg = (int) ( (INB(bktr, BKTR_E_CONTROL) & 0xe0) >> 5) ; 2043 break; 2044 2045 2046 /* */ 2047 case BT848_SCONT: /* set contrast */ 2048 tmp_int = *(int*)arg; 2049 2050 temp = INB(bktr, BKTR_E_CONTROL); 2051 temp1 = INB(bktr, BKTR_O_CONTROL); 2052 if ( tmp_int & BIT_EIGHT_HIGH ) { 2053 temp |= BT848_E_CONTROL_CON_MSB; 2054 temp1 |= BT848_O_CONTROL_CON_MSB; 2055 } 2056 else { 2057 temp &= ~BT848_E_CONTROL_CON_MSB; 2058 temp1 &= ~BT848_O_CONTROL_CON_MSB; 2059 } 2060 2061 OUTB(bktr, BKTR_CONTRAST_LO, (u_char)(tmp_int & 0xff)); 2062 OUTB(bktr, BKTR_E_CONTROL, temp); 2063 OUTB(bktr, BKTR_O_CONTROL, temp1); 2064 break; 2065 2066 case BT848_GCONT: /* get contrast */ 2067 tmp_int = (int)INB(bktr, BKTR_CONTRAST_LO) & 0xff; 2068 if ( INB(bktr, BKTR_E_CONTROL) & BT848_E_CONTROL_CON_MSB ) 2069 tmp_int |= BIT_EIGHT_HIGH; 2070 *(int*)arg = tmp_int; 2071 break; 2072 2073 /* FIXME: SCBARS and CCBARS require a valid int * */ 2074 /* argument to succeed, but its not used; consider */ 2075 /* using the arg to store the on/off state so */ 2076 /* there's only one ioctl() needed to turn cbars on/off */ 2077 case BT848_SCBARS: /* set colorbar output */ 2078 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_COLOR_BARS); 2079 break; 2080 2081 case BT848_CCBARS: /* clear colorbar output */ 2082 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) & ~(BT848_COLOR_CTL_COLOR_BARS)); 2083 break; 2084 2085 case BT848_GAUDIO: /* get audio channel */ 2086 temp = bktr->audio_mux_select; 2087 if ( bktr->audio_mute_state == TRUE ) 2088 temp |= AUDIO_MUTE; 2089 *(int*)arg = temp; 2090 break; 2091 2092 case BT848_SBTSC: /* set audio channel */ 2093 if ( set_BTSC( bktr, *(int*)arg ) < 0 ) 2094 return( EIO ); 2095 break; 2096 2097 case BT848_WEEPROM: /* write eeprom */ 2098 offset = (((struct eeProm *)arg)->offset); 2099 count = (((struct eeProm *)arg)->count); 2100 buf = &(((struct eeProm *)arg)->bytes[ 0 ]); 2101 if ( writeEEProm( bktr, offset, count, buf ) < 0 ) 2102 return( EIO ); 2103 break; 2104 2105 case BT848_REEPROM: /* read eeprom */ 2106 offset = (((struct eeProm *)arg)->offset); 2107 count = (((struct eeProm *)arg)->count); 2108 buf = &(((struct eeProm *)arg)->bytes[ 0 ]); 2109 if ( readEEProm( bktr, offset, count, buf ) < 0 ) 2110 return( EIO ); 2111 break; 2112 2113 case BT848_SIGNATURE: 2114 offset = (((struct eeProm *)arg)->offset); 2115 count = (((struct eeProm *)arg)->count); 2116 buf = &(((struct eeProm *)arg)->bytes[ 0 ]); 2117 if ( signCard( bktr, offset, count, buf ) < 0 ) 2118 return( EIO ); 2119 break; 2120 2121 /* Ioctl's for direct gpio access */ 2122 #ifdef BKTR_GPIO_ACCESS 2123 case BT848_GPIO_GET_EN: 2124 *(int*)arg = INL(bktr, BKTR_GPIO_OUT_EN); 2125 break; 2126 2127 case BT848_GPIO_SET_EN: 2128 OUTL(bktr, BKTR_GPIO_OUT_EN, *(int*)arg); 2129 break; 2130 2131 case BT848_GPIO_GET_DATA: 2132 *(int*)arg = INL(bktr, BKTR_GPIO_DATA); 2133 break; 2134 2135 case BT848_GPIO_SET_DATA: 2136 OUTL(bktr, BKTR_GPIO_DATA, *(int*)arg); 2137 break; 2138 #endif /* BKTR_GPIO_ACCESS */ 2139 2140 /* Ioctl's for running the tuner device in radio mode */ 2141 2142 case RADIO_GETMODE: 2143 *(unsigned char *)arg = bktr->tuner.radio_mode; 2144 break; 2145 2146 case RADIO_SETMODE: 2147 bktr->tuner.radio_mode = *(unsigned char *)arg; 2148 break; 2149 2150 case RADIO_GETFREQ: 2151 *(unsigned long *)arg = bktr->tuner.frequency; 2152 break; 2153 2154 case RADIO_SETFREQ: 2155 /* The argument to this ioctl is NOT freq*16. It is 2156 ** freq*100. 2157 */ 2158 2159 temp=(int)*(unsigned long *)arg; 2160 2161 #ifdef BKTR_RADIO_DEBUG 2162 printf("%s: arg=%d temp=%d\n", bktr_name(bktr), 2163 (int)*(unsigned long *)arg, temp); 2164 #endif 2165 2166 #ifndef BKTR_RADIO_NOFREQCHECK 2167 /* According to the spec. sheet the band: 87.5MHz-108MHz */ 2168 /* is supported. */ 2169 if(temp<8750 || temp>10800) { 2170 printf("%s: Radio frequency out of range\n", bktr_name(bktr)); 2171 return(EINVAL); 2172 } 2173 #endif 2174 temp_mute( bktr, TRUE ); 2175 temp = tv_freq( bktr, temp, FM_RADIO_FREQUENCY ); 2176 temp_mute( bktr, FALSE ); 2177 #ifdef BKTR_RADIO_DEBUG 2178 if(temp) 2179 printf("%s: tv_freq returned: %d\n", bktr_name(bktr), temp); 2180 #endif 2181 if ( temp < 0 ) 2182 return( EINVAL ); 2183 *(unsigned long *)arg = temp; 2184 break; 2185 2186 /* Luigi's I2CWR ioctl */ 2187 case BT848_I2CWR: 2188 par = *(u_long *)arg; 2189 write = (par >> 24) & 0xff ; 2190 i2c_addr = (par >> 16) & 0xff ; 2191 i2c_port = (par >> 8) & 0xff ; 2192 data = (par) & 0xff ; 2193 2194 if (write) { 2195 i2cWrite( bktr, i2c_addr, i2c_port, data); 2196 } else { 2197 data = i2cRead( bktr, i2c_addr); 2198 } 2199 *(u_long *)arg = (par & 0xffffff00) | ( data & 0xff ); 2200 break; 2201 2202 2203 #ifdef BT848_MSP_READ 2204 /* I2C ioctls to allow userland access to the MSP chip */ 2205 case BT848_MSP_READ: 2206 { 2207 struct bktr_msp_control *msp; 2208 msp = (struct bktr_msp_control *) arg; 2209 msp->data = msp_dpl_read(bktr, bktr->msp_addr, 2210 msp->function, msp->address); 2211 break; 2212 } 2213 2214 case BT848_MSP_WRITE: 2215 { 2216 struct bktr_msp_control *msp; 2217 msp = (struct bktr_msp_control *) arg; 2218 msp_dpl_write(bktr, bktr->msp_addr, msp->function, 2219 msp->address, msp->data ); 2220 break; 2221 } 2222 2223 case BT848_MSP_RESET: 2224 msp_dpl_reset(bktr, bktr->msp_addr); 2225 break; 2226 #endif 2227 2228 default: 2229 return common_ioctl( bktr, cmd, arg ); 2230 } 2231 2232 return( 0 ); 2233 } 2234 2235 2236 /* 2237 * common ioctls 2238 */ 2239 static int 2240 common_ioctl( bktr_ptr_t bktr, ioctl_cmd_t cmd, caddr_t arg ) 2241 { 2242 int pixfmt; 2243 unsigned int temp; 2244 struct meteor_pixfmt *pf_pub; 2245 2246 switch (cmd) { 2247 2248 case METEORSINPUT: /* set input device */ 2249 /*Bt848 has 3 MUX Inputs. Bt848A/849A/878/879 has 4 MUX Inputs*/ 2250 /* On the original bt848 boards, */ 2251 /* Tuner is MUX0, RCA is MUX1, S-Video is MUX2 */ 2252 /* On the Hauppauge bt878 boards, */ 2253 /* Tuner is MUX0, RCA is MUX3 */ 2254 /* Unfortunatly Meteor driver codes DEV_RCA as DEV_0, so we */ 2255 /* stick with this system in our Meteor Emulation */ 2256 2257 switch(*(unsigned long *)arg & METEOR_DEV_MASK) { 2258 2259 /* this is the RCA video input */ 2260 case 0: /* default */ 2261 case METEOR_INPUT_DEV0: 2262 /* METEOR_INPUT_DEV_RCA: */ 2263 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) 2264 | METEOR_DEV0; 2265 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) 2266 & ~BT848_IFORM_MUXSEL); 2267 2268 /* work around for new Hauppauge 878 cards */ 2269 if ((bktr->card.card_id == CARD_HAUPPAUGE) && 2270 (bktr->id==BROOKTREE_878 || 2271 bktr->id==BROOKTREE_879) ) 2272 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3); 2273 else 2274 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1); 2275 2276 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP); 2277 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP); 2278 set_audio( bktr, AUDIO_EXTERN ); 2279 break; 2280 2281 /* this is the tuner input */ 2282 case METEOR_INPUT_DEV1: 2283 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) 2284 | METEOR_DEV1; 2285 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL); 2286 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX0); 2287 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP); 2288 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP); 2289 set_audio( bktr, AUDIO_TUNER ); 2290 break; 2291 2292 /* this is the S-VHS input, but with a composite camera */ 2293 case METEOR_INPUT_DEV2: 2294 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) 2295 | METEOR_DEV2; 2296 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL); 2297 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2); 2298 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP); 2299 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_O_CONTROL_COMP); 2300 set_audio( bktr, AUDIO_EXTERN ); 2301 break; 2302 2303 /* this is the S-VHS input */ 2304 case METEOR_INPUT_DEV_SVIDEO: 2305 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) 2306 | METEOR_DEV_SVIDEO; 2307 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL); 2308 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX2); 2309 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_COMP); 2310 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_COMP); 2311 set_audio( bktr, AUDIO_EXTERN ); 2312 break; 2313 2314 case METEOR_INPUT_DEV3: 2315 if ((bktr->id == BROOKTREE_848A) || 2316 (bktr->id == BROOKTREE_849A) || 2317 (bktr->id == BROOKTREE_878) || 2318 (bktr->id == BROOKTREE_879) ) { 2319 bktr->flags = (bktr->flags & ~METEOR_DEV_MASK) 2320 | METEOR_DEV3; 2321 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) & ~BT848_IFORM_MUXSEL); 2322 2323 /* work around for new Hauppauge 878 cards */ 2324 if ((bktr->card.card_id == CARD_HAUPPAUGE) && 2325 (bktr->id==BROOKTREE_878 || 2326 bktr->id==BROOKTREE_879) ) 2327 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX1); 2328 else 2329 OUTB(bktr, BKTR_IFORM, INB(bktr, BKTR_IFORM) | BT848_IFORM_M_MUX3); 2330 2331 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) & ~BT848_E_CONTROL_COMP); 2332 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) & ~BT848_O_CONTROL_COMP); 2333 set_audio( bktr, AUDIO_EXTERN ); 2334 2335 break; 2336 } 2337 2338 default: 2339 return( EINVAL ); 2340 } 2341 break; 2342 2343 case METEORGINPUT: /* get input device */ 2344 *(u_long *)arg = bktr->flags & METEOR_DEV_MASK; 2345 break; 2346 2347 case METEORSACTPIXFMT: 2348 if (( *(int *)arg < 0 ) || 2349 ( *(int *)arg >= PIXFMT_TABLE_SIZE )) 2350 return( EINVAL ); 2351 2352 bktr->pixfmt = *(int *)arg; 2353 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0) 2354 | pixfmt_swap_flags( bktr->pixfmt )); 2355 bktr->pixfmt_compat = FALSE; 2356 break; 2357 2358 case METEORGACTPIXFMT: 2359 *(int *)arg = bktr->pixfmt; 2360 break; 2361 2362 case METEORGSUPPIXFMT : 2363 pf_pub = (struct meteor_pixfmt *)arg; 2364 pixfmt = pf_pub->index; 2365 2366 if (( pixfmt < 0 ) || ( pixfmt >= PIXFMT_TABLE_SIZE )) 2367 return( EINVAL ); 2368 2369 memcpy( pf_pub, &pixfmt_table[ pixfmt ].public, 2370 sizeof( *pf_pub ) ); 2371 2372 /* Patch in our format index */ 2373 pf_pub->index = pixfmt; 2374 break; 2375 2376 #if defined( STATUS_SUM ) 2377 case BT848_GSTATUS: /* reap status */ 2378 { 2379 crit_enter(); 2380 temp = status_sum; 2381 status_sum = 0; 2382 crit_exit(); 2383 *(u_int*)arg = temp; 2384 break; 2385 } 2386 #endif /* STATUS_SUM */ 2387 2388 default: 2389 return( ENOTTY ); 2390 } 2391 2392 return( 0 ); 2393 } 2394 2395 2396 2397 2398 /****************************************************************************** 2399 * bt848 RISC programming routines: 2400 */ 2401 2402 2403 /* 2404 * 2405 */ 2406 #ifdef BT848_DEBUG 2407 static int 2408 dump_bt848( bktr_ptr_t bktr ) 2409 { 2410 int r[60]={ 2411 4, 8, 0xc, 0x8c, 0x10, 0x90, 0x14, 0x94, 2412 0x18, 0x98, 0x1c, 0x9c, 0x20, 0xa0, 0x24, 0xa4, 2413 0x28, 0x2c, 0xac, 0x30, 0x34, 0x38, 0x3c, 0x40, 2414 0xc0, 0x48, 0x4c, 0xcc, 0x50, 0xd0, 0xd4, 0x60, 2415 0x64, 0x68, 0x6c, 0xec, 0xd8, 0xdc, 0xe0, 0xe4, 2416 0, 0, 0, 0 2417 }; 2418 int i; 2419 2420 for (i = 0; i < 40; i+=4) { 2421 printf("%s: Reg:value : \t%x:%x \t%x:%x \t %x:%x \t %x:%x\n", 2422 bktr_name(bktr), 2423 r[i], INL(bktr, r[i]), 2424 r[i+1], INL(bktr, r[i+1]), 2425 r[i+2], INL(bktr, r[i+2]), 2426 r[i+3], INL(bktr, r[i+3]])); 2427 } 2428 2429 printf("%s: INT STAT %x \n", bktr_name(bktr), 2430 INL(bktr, BKTR_INT_STAT)); 2431 printf("%s: Reg INT_MASK %x \n", bktr_name(bktr), 2432 INL(bktr, BKTR_INT_MASK)); 2433 printf("%s: Reg GPIO_DMA_CTL %x \n", bktr_name(bktr), 2434 INW(bktr, BKTR_GPIO_DMA_CTL)); 2435 2436 return( 0 ); 2437 } 2438 2439 #endif 2440 2441 /* 2442 * build write instruction 2443 */ 2444 #define BKTR_FM1 0x6 /* packed data to follow */ 2445 #define BKTR_FM3 0xe /* planar data to follow */ 2446 #define BKTR_VRE 0x4 /* Marks the end of the even field */ 2447 #define BKTR_VRO 0xC /* Marks the end of the odd field */ 2448 #define BKTR_PXV 0x0 /* valid word (never used) */ 2449 #define BKTR_EOL 0x1 /* last dword, 4 bytes */ 2450 #define BKTR_SOL 0x2 /* first dword */ 2451 2452 #define OP_WRITE (0x1 << 28) 2453 #define OP_SKIP (0x2 << 28) 2454 #define OP_WRITEC (0x5 << 28) 2455 #define OP_JUMP (0x7 << 28) 2456 #define OP_SYNC (0x8 << 28) 2457 #define OP_WRITE123 (0x9 << 28) 2458 #define OP_WRITES123 (0xb << 28) 2459 #define OP_SOL (1 << 27) /* first instr for scanline */ 2460 #define OP_EOL (1 << 26) 2461 2462 #define BKTR_RESYNC (1 << 15) 2463 #define BKTR_GEN_IRQ (1 << 24) 2464 2465 /* 2466 * The RISC status bits can be set/cleared in the RISC programs 2467 * and tested in the Interrupt Handler 2468 */ 2469 #define BKTR_SET_RISC_STATUS_BIT0 (1 << 16) 2470 #define BKTR_SET_RISC_STATUS_BIT1 (1 << 17) 2471 #define BKTR_SET_RISC_STATUS_BIT2 (1 << 18) 2472 #define BKTR_SET_RISC_STATUS_BIT3 (1 << 19) 2473 2474 #define BKTR_CLEAR_RISC_STATUS_BIT0 (1 << 20) 2475 #define BKTR_CLEAR_RISC_STATUS_BIT1 (1 << 21) 2476 #define BKTR_CLEAR_RISC_STATUS_BIT2 (1 << 22) 2477 #define BKTR_CLEAR_RISC_STATUS_BIT3 (1 << 23) 2478 2479 #define BKTR_TEST_RISC_STATUS_BIT0 (1 << 28) 2480 #define BKTR_TEST_RISC_STATUS_BIT1 (1 << 29) 2481 #define BKTR_TEST_RISC_STATUS_BIT2 (1 << 30) 2482 #define BKTR_TEST_RISC_STATUS_BIT3 (1 << 31) 2483 2484 static bool_t notclipped (bktr_reg_t * bktr, int x, int width) { 2485 int i; 2486 bktr_clip_t * clip_node; 2487 bktr->clip_start = -1; 2488 bktr->last_y = 0; 2489 bktr->y = 0; 2490 bktr->y2 = width; 2491 bktr->line_length = width; 2492 bktr->yclip = -1; 2493 bktr->yclip2 = -1; 2494 bktr->current_col = 0; 2495 2496 if (bktr->max_clip_node == 0 ) return TRUE; 2497 clip_node = (bktr_clip_t *) &bktr->clip_list[0]; 2498 2499 2500 for (i = 0; i < bktr->max_clip_node; i++ ) { 2501 clip_node = (bktr_clip_t *) &bktr->clip_list[i]; 2502 if (x >= clip_node->x_min && x <= clip_node->x_max ) { 2503 bktr->clip_start = i; 2504 return FALSE; 2505 } 2506 } 2507 2508 return TRUE; 2509 } 2510 2511 static bool_t getline(bktr_reg_t *bktr, int x ) { 2512 int i, j; 2513 bktr_clip_t * clip_node ; 2514 2515 if (bktr->line_length == 0 || 2516 bktr->current_col >= bktr->line_length) return FALSE; 2517 2518 bktr->y = min(bktr->last_y, bktr->line_length); 2519 bktr->y2 = bktr->line_length; 2520 2521 bktr->yclip = bktr->yclip2 = -1; 2522 for (i = bktr->clip_start; i < bktr->max_clip_node; i++ ) { 2523 clip_node = (bktr_clip_t *) &bktr->clip_list[i]; 2524 if (x >= clip_node->x_min && x <= clip_node->x_max) { 2525 if (bktr->last_y <= clip_node->y_min) { 2526 bktr->y = min(bktr->last_y, bktr->line_length); 2527 bktr->y2 = min(clip_node->y_min, bktr->line_length); 2528 bktr->yclip = min(clip_node->y_min, bktr->line_length); 2529 bktr->yclip2 = min(clip_node->y_max, bktr->line_length); 2530 bktr->last_y = bktr->yclip2; 2531 bktr->clip_start = i; 2532 2533 for (j = i+1; j < bktr->max_clip_node; j++ ) { 2534 clip_node = (bktr_clip_t *) &bktr->clip_list[j]; 2535 if (x >= clip_node->x_min && x <= clip_node->x_max) { 2536 if (bktr->last_y >= clip_node->y_min) { 2537 bktr->yclip2 = min(clip_node->y_max, bktr->line_length); 2538 bktr->last_y = bktr->yclip2; 2539 bktr->clip_start = j; 2540 } 2541 } else break ; 2542 } 2543 return TRUE; 2544 } 2545 } 2546 } 2547 2548 if (bktr->current_col <= bktr->line_length) { 2549 bktr->current_col = bktr->line_length; 2550 return TRUE; 2551 } 2552 return FALSE; 2553 } 2554 2555 static bool_t split(bktr_reg_t * bktr, volatile uint32_t **dma_prog, int width , 2556 u_long operation, int pixel_width, 2557 volatile u_char ** target_buffer, int cols ) { 2558 2559 u_long flag, flag2; 2560 struct meteor_pixfmt *pf = &pixfmt_table[ bktr->pixfmt ].public; 2561 u_int skip, start_skip; 2562 2563 /* For RGB24, we need to align the component in FIFO Byte Lane 0 */ 2564 /* to the 1st byte in the mem dword containing our start addr. */ 2565 /* BTW, we know this pixfmt's 1st byte is Blue; thus the start addr */ 2566 /* must be Blue. */ 2567 start_skip = 0; 2568 if (( pf->type == METEOR_PIXTYPE_RGB ) && ( pf->Bpp == 3 )) 2569 switch ( ((uintptr_t) (volatile void *) *target_buffer) % 4 ) { 2570 case 2 : start_skip = 4 ; break; 2571 case 1 : start_skip = 8 ; break; 2572 } 2573 2574 if ((width * pixel_width) < DMA_BT848_SPLIT ) { 2575 if ( width == cols) { 2576 flag = OP_SOL | OP_EOL; 2577 } else if (bktr->current_col == 0 ) { 2578 flag = OP_SOL; 2579 } else if (bktr->current_col == cols) { 2580 flag = OP_EOL; 2581 } else flag = 0; 2582 2583 skip = 0; 2584 if (( flag & OP_SOL ) && ( start_skip > 0 )) { 2585 *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip; 2586 flag &= ~OP_SOL; 2587 skip = start_skip; 2588 } 2589 2590 *(*dma_prog)++ = operation | flag | (width * pixel_width - skip); 2591 if (operation != OP_SKIP ) 2592 *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer; 2593 2594 *target_buffer += width * pixel_width; 2595 bktr->current_col += width; 2596 2597 } else { 2598 2599 if (bktr->current_col == 0 && width == cols) { 2600 flag = OP_SOL ; 2601 flag2 = OP_EOL; 2602 } else if (bktr->current_col == 0 ) { 2603 flag = OP_SOL; 2604 flag2 = 0; 2605 } else if (bktr->current_col >= cols) { 2606 flag = 0; 2607 flag2 = OP_EOL; 2608 } else { 2609 flag = 0; 2610 flag2 = 0; 2611 } 2612 2613 skip = 0; 2614 if (( flag & OP_SOL ) && ( start_skip > 0 )) { 2615 *(*dma_prog)++ = OP_SKIP | OP_SOL | start_skip; 2616 flag &= ~OP_SOL; 2617 skip = start_skip; 2618 } 2619 2620 *(*dma_prog)++ = operation | flag | 2621 (width * pixel_width / 2 - skip); 2622 if (operation != OP_SKIP ) 2623 *(*dma_prog)++ = (uintptr_t) (volatile void *) *target_buffer ; 2624 *target_buffer += (width * pixel_width / 2) ; 2625 2626 if ( operation == OP_WRITE ) 2627 operation = OP_WRITEC; 2628 *(*dma_prog)++ = operation | flag2 | 2629 (width * pixel_width / 2); 2630 *target_buffer += (width * pixel_width / 2) ; 2631 bktr->current_col += width; 2632 2633 } 2634 return TRUE; 2635 } 2636 2637 2638 /* 2639 * Generate the RISC instructions to capture both VBI and video images 2640 */ 2641 static void 2642 rgb_vbi_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace ) 2643 { 2644 int i; 2645 volatile uint32_t target_buffer, buffer, target,width; 2646 volatile uint32_t pitch; 2647 volatile uint32_t *dma_prog; /* DMA prog is an array of 2648 32 bit RISC instructions */ 2649 volatile uint32_t *loop_point; 2650 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 2651 u_int Bpp = pf_int->public.Bpp; 2652 unsigned int vbisamples; /* VBI samples per line */ 2653 unsigned int vbilines; /* VBI lines per field */ 2654 unsigned int num_dwords; /* DWORDS per line */ 2655 2656 vbisamples = format_params[bktr->format_params].vbi_num_samples; 2657 vbilines = format_params[bktr->format_params].vbi_num_lines; 2658 num_dwords = vbisamples/4; 2659 2660 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt); 2661 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 2662 OUTB(bktr, BKTR_VBI_PACK_SIZE, ((num_dwords)) & 0xff); 2663 OUTB(bktr, BKTR_VBI_PACK_DEL, ((num_dwords)>> 8) & 0x01); /* no hdelay */ 2664 /* no ext frame */ 2665 2666 OUTB(bktr, BKTR_OFORM, 0x00); 2667 2668 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */ 2669 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40); 2670 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */ 2671 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80); 2672 2673 /* disable gamma correction removal */ 2674 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA); 2675 2676 if (cols > 385 ) { 2677 OUTB(bktr, BKTR_E_VTC, 0); 2678 OUTB(bktr, BKTR_O_VTC, 0); 2679 } else { 2680 OUTB(bktr, BKTR_E_VTC, 1); 2681 OUTB(bktr, BKTR_O_VTC, 1); 2682 } 2683 bktr->capcontrol = 3 << 2 | 3; 2684 2685 dma_prog = (uint32_t *) bktr->dma_prog; 2686 2687 /* Construct Write */ 2688 2689 if (bktr->video.addr) { 2690 target_buffer = (u_long) bktr->video.addr; 2691 pitch = bktr->video.width; 2692 } 2693 else { 2694 target_buffer = (u_long) vtophys(bktr->bigbuf); 2695 pitch = cols*Bpp; 2696 } 2697 2698 buffer = target_buffer; 2699 2700 /* Wait for the VRE sync marking the end of the Even and 2701 * the start of the Odd field. Resync here. 2702 */ 2703 *dma_prog++ = OP_SYNC | BKTR_RESYNC |BKTR_VRE; 2704 *dma_prog++ = 0; 2705 2706 loop_point = dma_prog; 2707 2708 /* store the VBI data */ 2709 /* look for sync with packed data */ 2710 *dma_prog++ = OP_SYNC | BKTR_FM1; 2711 *dma_prog++ = 0; 2712 for(i = 0; i < vbilines; i++) { 2713 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples; 2714 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata + 2715 (i * VBI_LINE_SIZE)); 2716 } 2717 2718 if ( (i_flag == 2/*Odd*/) || (i_flag==3) /*interlaced*/ ) { 2719 /* store the Odd field video image */ 2720 /* look for sync with packed data */ 2721 *dma_prog++ = OP_SYNC | BKTR_FM1; 2722 *dma_prog++ = 0; /* NULL WORD */ 2723 width = cols; 2724 for (i = 0; i < (rows/interlace); i++) { 2725 target = target_buffer; 2726 if ( notclipped(bktr, i, width)) { 2727 split(bktr, (volatile uint32_t **) &dma_prog, 2728 bktr->y2 - bktr->y, OP_WRITE, 2729 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2730 2731 } else { 2732 while(getline(bktr, i)) { 2733 if (bktr->y != bktr->y2 ) { 2734 split(bktr, (volatile uint32_t **) &dma_prog, 2735 bktr->y2 - bktr->y, OP_WRITE, 2736 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2737 } 2738 if (bktr->yclip != bktr->yclip2 ) { 2739 split(bktr,(volatile uint32_t **) &dma_prog, 2740 bktr->yclip2 - bktr->yclip, 2741 OP_SKIP, 2742 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2743 } 2744 } 2745 2746 } 2747 2748 target_buffer += interlace * pitch; 2749 2750 } 2751 2752 } /* end if */ 2753 2754 /* Grab the Even field */ 2755 /* Look for the VRO, end of Odd field, marker */ 2756 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; 2757 *dma_prog++ = 0; /* NULL WORD */ 2758 2759 /* store the VBI data */ 2760 /* look for sync with packed data */ 2761 *dma_prog++ = OP_SYNC | BKTR_FM1; 2762 *dma_prog++ = 0; 2763 for(i = 0; i < vbilines; i++) { 2764 *dma_prog++ = OP_WRITE | OP_SOL | OP_EOL | vbisamples; 2765 *dma_prog++ = (u_long) vtophys((caddr_t)bktr->vbidata + 2766 ((i+MAX_VBI_LINES) * VBI_LINE_SIZE)); 2767 } 2768 2769 /* store the video image */ 2770 if (i_flag == 1) /*Even Only*/ 2771 target_buffer = buffer; 2772 if (i_flag == 3) /*interlaced*/ 2773 target_buffer = buffer+pitch; 2774 2775 2776 if ((i_flag == 1) /*Even Only*/ || (i_flag==3) /*interlaced*/) { 2777 /* look for sync with packed data */ 2778 *dma_prog++ = OP_SYNC | BKTR_FM1; 2779 *dma_prog++ = 0; /* NULL WORD */ 2780 width = cols; 2781 for (i = 0; i < (rows/interlace); i++) { 2782 target = target_buffer; 2783 if ( notclipped(bktr, i, width)) { 2784 split(bktr, (volatile uint32_t **) &dma_prog, 2785 bktr->y2 - bktr->y, OP_WRITE, 2786 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2787 } else { 2788 while(getline(bktr, i)) { 2789 if (bktr->y != bktr->y2 ) { 2790 split(bktr, (volatile uint32_t **) &dma_prog, 2791 bktr->y2 - bktr->y, OP_WRITE, 2792 Bpp, (volatile u_char **)(uintptr_t)&target, 2793 cols); 2794 } 2795 if (bktr->yclip != bktr->yclip2 ) { 2796 split(bktr, (volatile uint32_t **) &dma_prog, 2797 bktr->yclip2 - bktr->yclip, OP_SKIP, 2798 Bpp, (volatile u_char **)(uintptr_t) &target, cols); 2799 } 2800 2801 } 2802 2803 } 2804 2805 target_buffer += interlace * pitch; 2806 2807 } 2808 } 2809 2810 /* Look for end of 'Even Field' */ 2811 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; 2812 *dma_prog++ = 0; /* NULL WORD */ 2813 2814 *dma_prog++ = OP_JUMP ; 2815 *dma_prog++ = (u_long ) vtophys(loop_point) ; 2816 *dma_prog++ = 0; /* NULL WORD */ 2817 2818 } 2819 2820 2821 2822 2823 static void 2824 rgb_prog( bktr_ptr_t bktr, char i_flag, int cols, int rows, int interlace ) 2825 { 2826 int i; 2827 volatile uint32_t target_buffer, buffer, target,width; 2828 volatile uint32_t pitch; 2829 volatile uint32_t *dma_prog; 2830 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 2831 u_int Bpp = pf_int->public.Bpp; 2832 2833 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt); 2834 OUTB(bktr, BKTR_VBI_PACK_SIZE, 0); 2835 OUTB(bktr, BKTR_VBI_PACK_DEL, 0); 2836 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 2837 2838 OUTB(bktr, BKTR_OFORM, 0x00); 2839 2840 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */ 2841 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40); 2842 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */ 2843 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80); 2844 2845 /* disable gamma correction removal */ 2846 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA); 2847 2848 if (cols > 385 ) { 2849 OUTB(bktr, BKTR_E_VTC, 0); 2850 OUTB(bktr, BKTR_O_VTC, 0); 2851 } else { 2852 OUTB(bktr, BKTR_E_VTC, 1); 2853 OUTB(bktr, BKTR_O_VTC, 1); 2854 } 2855 bktr->capcontrol = 3 << 2 | 3; 2856 2857 dma_prog = (uint32_t *) bktr->dma_prog; 2858 2859 /* Construct Write */ 2860 2861 if (bktr->video.addr) { 2862 target_buffer = (uint32_t) bktr->video.addr; 2863 pitch = bktr->video.width; 2864 } 2865 else { 2866 target_buffer = (uint32_t) vtophys(bktr->bigbuf); 2867 pitch = cols*Bpp; 2868 } 2869 2870 buffer = target_buffer; 2871 2872 /* contruct sync : for video packet format */ 2873 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; 2874 2875 /* sync, mode indicator packed data */ 2876 *dma_prog++ = 0; /* NULL WORD */ 2877 width = cols; 2878 for (i = 0; i < (rows/interlace); i++) { 2879 target = target_buffer; 2880 if ( notclipped(bktr, i, width)) { 2881 split(bktr, (volatile uint32_t **) &dma_prog, 2882 bktr->y2 - bktr->y, OP_WRITE, 2883 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2884 2885 } else { 2886 while(getline(bktr, i)) { 2887 if (bktr->y != bktr->y2 ) { 2888 split(bktr, (volatile uint32_t **) &dma_prog, 2889 bktr->y2 - bktr->y, OP_WRITE, 2890 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2891 } 2892 if (bktr->yclip != bktr->yclip2 ) { 2893 split(bktr,(volatile uint32_t **) &dma_prog, 2894 bktr->yclip2 - bktr->yclip, 2895 OP_SKIP, 2896 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2897 } 2898 } 2899 2900 } 2901 2902 target_buffer += interlace * pitch; 2903 2904 } 2905 2906 switch (i_flag) { 2907 case 1: 2908 /* sync vre */ 2909 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO; 2910 *dma_prog++ = 0; /* NULL WORD */ 2911 2912 *dma_prog++ = OP_JUMP; 2913 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog); 2914 return; 2915 2916 case 2: 2917 /* sync vro */ 2918 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE; 2919 *dma_prog++ = 0; /* NULL WORD */ 2920 2921 *dma_prog++ = OP_JUMP; 2922 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog); 2923 return; 2924 2925 case 3: 2926 /* sync vro */ 2927 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; 2928 *dma_prog++ = 0; /* NULL WORD */ 2929 *dma_prog++ = OP_JUMP; ; 2930 *dma_prog = (uint32_t ) vtophys(bktr->odd_dma_prog); 2931 break; 2932 } 2933 2934 if (interlace == 2) { 2935 2936 target_buffer = buffer + pitch; 2937 2938 dma_prog = (uint32_t *) bktr->odd_dma_prog; 2939 2940 /* sync vre IRQ bit */ 2941 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; 2942 *dma_prog++ = 0; /* NULL WORD */ 2943 width = cols; 2944 for (i = 0; i < (rows/interlace); i++) { 2945 target = target_buffer; 2946 if ( notclipped(bktr, i, width)) { 2947 split(bktr, (volatile uint32_t **) &dma_prog, 2948 bktr->y2 - bktr->y, OP_WRITE, 2949 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2950 } else { 2951 while(getline(bktr, i)) { 2952 if (bktr->y != bktr->y2 ) { 2953 split(bktr, (volatile uint32_t **) &dma_prog, 2954 bktr->y2 - bktr->y, OP_WRITE, 2955 Bpp, (volatile u_char **)(uintptr_t)&target, 2956 cols); 2957 } 2958 if (bktr->yclip != bktr->yclip2 ) { 2959 split(bktr, (volatile uint32_t **) &dma_prog, 2960 bktr->yclip2 - bktr->yclip, OP_SKIP, 2961 Bpp, (volatile u_char **)(uintptr_t)&target, cols); 2962 } 2963 2964 } 2965 2966 } 2967 2968 target_buffer += interlace * pitch; 2969 2970 } 2971 } 2972 2973 /* sync vre IRQ bit */ 2974 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; 2975 *dma_prog++ = 0; /* NULL WORD */ 2976 *dma_prog++ = OP_JUMP ; 2977 *dma_prog++ = (uint32_t ) vtophys(bktr->dma_prog) ; 2978 *dma_prog++ = 0; /* NULL WORD */ 2979 } 2980 2981 2982 /* 2983 * 2984 */ 2985 static void 2986 yuvpack_prog( bktr_ptr_t bktr, char i_flag, 2987 int cols, int rows, int interlace ) 2988 { 2989 int i; 2990 volatile unsigned int inst; 2991 volatile unsigned int inst3; 2992 volatile uint32_t target_buffer, buffer; 2993 volatile uint32_t *dma_prog; 2994 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 2995 int b; 2996 2997 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt); 2998 2999 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* enable chroma comb */ 3000 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC); 3001 3002 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_RGB_DED | BT848_COLOR_CTL_GAMMA); 3003 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 3004 3005 bktr->capcontrol = 1 << 6 | 1 << 4 | 1 << 2 | 3; 3006 bktr->capcontrol = 3 << 2 | 3; 3007 3008 dma_prog = (uint32_t *) bktr->dma_prog; 3009 3010 /* Construct Write */ 3011 3012 /* write , sol, eol */ 3013 inst = OP_WRITE | OP_SOL | (cols); 3014 /* write , sol, eol */ 3015 inst3 = OP_WRITE | OP_EOL | (cols); 3016 3017 if (bktr->video.addr) 3018 target_buffer = (uint32_t) bktr->video.addr; 3019 else 3020 target_buffer = (uint32_t) vtophys(bktr->bigbuf); 3021 3022 buffer = target_buffer; 3023 3024 /* contruct sync : for video packet format */ 3025 /* sync, mode indicator packed data */ 3026 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; 3027 *dma_prog++ = 0; /* NULL WORD */ 3028 3029 b = cols; 3030 3031 for (i = 0; i < (rows/interlace); i++) { 3032 *dma_prog++ = inst; 3033 *dma_prog++ = target_buffer; 3034 *dma_prog++ = inst3; 3035 *dma_prog++ = target_buffer + b; 3036 target_buffer += interlace*(cols * 2); 3037 } 3038 3039 switch (i_flag) { 3040 case 1: 3041 /* sync vre */ 3042 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRE; 3043 *dma_prog++ = 0; /* NULL WORD */ 3044 3045 *dma_prog++ = OP_JUMP; 3046 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3047 return; 3048 3049 case 2: 3050 /* sync vro */ 3051 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_VRO; 3052 *dma_prog++ = 0; /* NULL WORD */ 3053 *dma_prog++ = OP_JUMP; 3054 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3055 return; 3056 3057 case 3: 3058 /* sync vro */ 3059 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRO; 3060 *dma_prog++ = 0; /* NULL WORD */ 3061 *dma_prog++ = OP_JUMP ; 3062 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog); 3063 break; 3064 } 3065 3066 if (interlace == 2) { 3067 3068 target_buffer = (uint32_t) buffer + cols*2; 3069 3070 dma_prog = (uint32_t *) bktr->odd_dma_prog; 3071 3072 /* sync vre */ 3073 *dma_prog++ = OP_SYNC | BKTR_RESYNC | BKTR_FM1; 3074 *dma_prog++ = 0; /* NULL WORD */ 3075 3076 for (i = 0; i < (rows/interlace) ; i++) { 3077 *dma_prog++ = inst; 3078 *dma_prog++ = target_buffer; 3079 *dma_prog++ = inst3; 3080 *dma_prog++ = target_buffer + b; 3081 target_buffer += interlace * ( cols*2); 3082 } 3083 } 3084 3085 /* sync vro IRQ bit */ 3086 *dma_prog++ = OP_SYNC | BKTR_GEN_IRQ | BKTR_RESYNC | BKTR_VRE; 3087 *dma_prog++ = 0; /* NULL WORD */ 3088 *dma_prog++ = OP_JUMP ; 3089 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3090 3091 *dma_prog++ = OP_JUMP; 3092 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3093 *dma_prog++ = 0; /* NULL WORD */ 3094 } 3095 3096 3097 /* 3098 * 3099 */ 3100 static void 3101 yuv422_prog( bktr_ptr_t bktr, char i_flag, 3102 int cols, int rows, int interlace ){ 3103 3104 int i; 3105 volatile unsigned int inst; 3106 volatile uint32_t target_buffer, t1, buffer; 3107 volatile uint32_t *dma_prog; 3108 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 3109 3110 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt); 3111 3112 dma_prog = (uint32_t*) bktr->dma_prog; 3113 3114 bktr->capcontrol = 1 << 6 | 1 << 4 | 3; 3115 3116 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 3117 OUTB(bktr, BKTR_OFORM, 0x00); 3118 3119 OUTB(bktr, BKTR_E_CONTROL, INB(bktr, BKTR_E_CONTROL) | BT848_E_CONTROL_LDEC); /* disable luma decimation */ 3120 OUTB(bktr, BKTR_O_CONTROL, INB(bktr, BKTR_O_CONTROL) | BT848_O_CONTROL_LDEC); 3121 3122 OUTB(bktr, BKTR_E_SCLOOP, INB(bktr, BKTR_E_SCLOOP) | BT848_E_SCLOOP_CAGC); /* chroma agc enable */ 3123 OUTB(bktr, BKTR_O_SCLOOP, INB(bktr, BKTR_O_SCLOOP) | BT848_O_SCLOOP_CAGC); 3124 3125 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x80); /* clear Ycomb */ 3126 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x80); 3127 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x40); /* set chroma comb */ 3128 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x40); 3129 3130 /* disable gamma correction removal */ 3131 OUTB(bktr, BKTR_COLOR_CTL, INB(bktr, BKTR_COLOR_CTL) | BT848_COLOR_CTL_GAMMA); 3132 3133 /* Construct Write */ 3134 inst = OP_WRITE123 | OP_SOL | OP_EOL | (cols); 3135 if (bktr->video.addr) 3136 target_buffer = (uint32_t) bktr->video.addr; 3137 else 3138 target_buffer = (uint32_t) vtophys(bktr->bigbuf); 3139 3140 buffer = target_buffer; 3141 3142 t1 = buffer; 3143 3144 /* contruct sync : for video packet format */ 3145 *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; /*sync, mode indicator packed data*/ 3146 *dma_prog++ = 0; /* NULL WORD */ 3147 3148 for (i = 0; i < (rows/interlace ) ; i++) { 3149 *dma_prog++ = inst; 3150 *dma_prog++ = cols/2 | cols/2 << 16; 3151 *dma_prog++ = target_buffer; 3152 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; 3153 *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace; 3154 target_buffer += interlace*cols; 3155 } 3156 3157 switch (i_flag) { 3158 case 1: 3159 *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRE; /*sync vre*/ 3160 *dma_prog++ = 0; /* NULL WORD */ 3161 3162 *dma_prog++ = OP_JUMP ; 3163 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3164 return; 3165 3166 case 2: 3167 *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRO; /*sync vre*/ 3168 *dma_prog++ = 0; /* NULL WORD */ 3169 3170 *dma_prog++ = OP_JUMP; 3171 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3172 return; 3173 3174 case 3: 3175 *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO; 3176 *dma_prog++ = 0; /* NULL WORD */ 3177 3178 *dma_prog++ = OP_JUMP ; 3179 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog); 3180 break; 3181 } 3182 3183 if (interlace == 2) { 3184 3185 dma_prog = (uint32_t *) bktr->odd_dma_prog; 3186 3187 target_buffer = (uint32_t) buffer + cols; 3188 t1 = buffer + cols/2; 3189 *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; 3190 *dma_prog++ = 0; /* NULL WORD */ 3191 3192 for (i = 0; i < (rows/interlace ) ; i++) { 3193 *dma_prog++ = inst; 3194 *dma_prog++ = cols/2 | cols/2 << 16; 3195 *dma_prog++ = target_buffer; 3196 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; 3197 *dma_prog++ = t1 + (cols*rows) + (cols*rows/2) + i*cols/2 * interlace; 3198 target_buffer += interlace*cols; 3199 } 3200 } 3201 3202 *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE; 3203 *dma_prog++ = 0; /* NULL WORD */ 3204 *dma_prog++ = OP_JUMP ; 3205 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog) ; 3206 *dma_prog++ = 0; /* NULL WORD */ 3207 } 3208 3209 3210 /* 3211 * 3212 */ 3213 static void 3214 yuv12_prog( bktr_ptr_t bktr, char i_flag, 3215 int cols, int rows, int interlace ){ 3216 3217 int i; 3218 volatile unsigned int inst; 3219 volatile unsigned int inst1; 3220 volatile uint32_t target_buffer, t1, buffer; 3221 volatile uint32_t *dma_prog; 3222 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 3223 3224 OUTB(bktr, BKTR_COLOR_FMT, pf_int->color_fmt); 3225 3226 dma_prog = (uint32_t *) bktr->dma_prog; 3227 3228 bktr->capcontrol = 1 << 6 | 1 << 4 | 3; 3229 3230 OUTB(bktr, BKTR_ADC, SYNC_LEVEL); 3231 OUTB(bktr, BKTR_OFORM, 0x0); 3232 3233 /* Construct Write */ 3234 inst = OP_WRITE123 | OP_SOL | OP_EOL | (cols); 3235 inst1 = OP_WRITES123 | OP_SOL | OP_EOL | (cols); 3236 if (bktr->video.addr) 3237 target_buffer = (uint32_t) bktr->video.addr; 3238 else 3239 target_buffer = (uint32_t) vtophys(bktr->bigbuf); 3240 3241 buffer = target_buffer; 3242 t1 = buffer; 3243 3244 *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; /*sync, mode indicator packed data*/ 3245 *dma_prog++ = 0; /* NULL WORD */ 3246 3247 for (i = 0; i < (rows/interlace )/2 ; i++) { 3248 *dma_prog++ = inst; 3249 *dma_prog++ = cols/2 | (cols/2 << 16); 3250 *dma_prog++ = target_buffer; 3251 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; 3252 *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace; 3253 target_buffer += interlace*cols; 3254 *dma_prog++ = inst1; 3255 *dma_prog++ = cols/2 | (cols/2 << 16); 3256 *dma_prog++ = target_buffer; 3257 target_buffer += interlace*cols; 3258 3259 } 3260 3261 switch (i_flag) { 3262 case 1: 3263 *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRE; /*sync vre*/ 3264 *dma_prog++ = 0; /* NULL WORD */ 3265 3266 *dma_prog++ = OP_JUMP; 3267 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3268 return; 3269 3270 case 2: 3271 *dma_prog++ = OP_SYNC | 1 << 24 | BKTR_VRO; /*sync vro*/ 3272 *dma_prog++ = 0; /* NULL WORD */ 3273 3274 *dma_prog++ = OP_JUMP; 3275 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3276 return; 3277 3278 case 3: 3279 *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRO; 3280 *dma_prog++ = 0; /* NULL WORD */ 3281 *dma_prog++ = OP_JUMP ; 3282 *dma_prog = (uint32_t) vtophys(bktr->odd_dma_prog); 3283 break; 3284 } 3285 3286 if (interlace == 2) { 3287 3288 dma_prog = (uint32_t *) bktr->odd_dma_prog; 3289 3290 target_buffer = (uint32_t) buffer + cols; 3291 t1 = buffer + cols/2; 3292 *dma_prog++ = OP_SYNC | 1 << 15 | BKTR_FM3; 3293 *dma_prog++ = 0; /* NULL WORD */ 3294 3295 for (i = 0; i < ((rows/interlace )/2 ) ; i++) { 3296 *dma_prog++ = inst; 3297 *dma_prog++ = cols/2 | (cols/2 << 16); 3298 *dma_prog++ = target_buffer; 3299 *dma_prog++ = t1 + (cols*rows) + i*cols/2 * interlace; 3300 *dma_prog++ = t1 + (cols*rows) + (cols*rows/4) + i*cols/2 * interlace; 3301 target_buffer += interlace*cols; 3302 *dma_prog++ = inst1; 3303 *dma_prog++ = cols/2 | (cols/2 << 16); 3304 *dma_prog++ = target_buffer; 3305 target_buffer += interlace*cols; 3306 3307 } 3308 3309 3310 } 3311 3312 *dma_prog++ = OP_SYNC | 1 << 24 | 1 << 15 | BKTR_VRE; 3313 *dma_prog++ = 0; /* NULL WORD */ 3314 *dma_prog++ = OP_JUMP; 3315 *dma_prog++ = (uint32_t) vtophys(bktr->dma_prog); 3316 *dma_prog++ = 0; /* NULL WORD */ 3317 } 3318 3319 3320 3321 /* 3322 * 3323 */ 3324 static void 3325 build_dma_prog( bktr_ptr_t bktr, char i_flag ) 3326 { 3327 int rows, cols, interlace; 3328 int tmp_int; 3329 unsigned int temp; 3330 struct format_params *fp; 3331 struct meteor_pixfmt_internal *pf_int = &pixfmt_table[ bktr->pixfmt ]; 3332 3333 3334 fp = &format_params[bktr->format_params]; 3335 3336 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 3337 3338 /* disable FIFO & RISC, leave other bits alone */ 3339 OUTW(bktr, BKTR_GPIO_DMA_CTL, INW(bktr, BKTR_GPIO_DMA_CTL) & ~FIFO_RISC_ENABLED); 3340 3341 /* set video parameters */ 3342 if (bktr->capture_area_enabled) 3343 temp = ((quad_t ) fp->htotal* (quad_t) bktr->capture_area_x_size * 4096 3344 / fp->scaled_htotal / bktr->cols) - 4096; 3345 else 3346 temp = ((quad_t ) fp->htotal* (quad_t) fp->scaled_hactive * 4096 3347 / fp->scaled_htotal / bktr->cols) - 4096; 3348 3349 /* printf("%s: HSCALE value is %d\n", bktr_name(bktr), temp); */ 3350 OUTB(bktr, BKTR_E_HSCALE_LO, temp & 0xff); 3351 OUTB(bktr, BKTR_O_HSCALE_LO, temp & 0xff); 3352 OUTB(bktr, BKTR_E_HSCALE_HI, (temp >> 8) & 0xff); 3353 OUTB(bktr, BKTR_O_HSCALE_HI, (temp >> 8) & 0xff); 3354 3355 /* horizontal active */ 3356 temp = bktr->cols; 3357 /* printf("%s: HACTIVE value is %d\n", bktr_name(bktr), temp); */ 3358 OUTB(bktr, BKTR_E_HACTIVE_LO, temp & 0xff); 3359 OUTB(bktr, BKTR_O_HACTIVE_LO, temp & 0xff); 3360 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x3); 3361 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x3); 3362 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 8) & 0x3)); 3363 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 8) & 0x3)); 3364 3365 /* horizontal delay */ 3366 if (bktr->capture_area_enabled) 3367 temp = ( (fp->hdelay* fp->scaled_hactive + bktr->capture_area_x_offset* fp->scaled_htotal) 3368 * bktr->cols) / (bktr->capture_area_x_size * fp->hactive); 3369 else 3370 temp = (fp->hdelay * bktr->cols) / fp->hactive; 3371 3372 temp = temp & 0x3fe; 3373 3374 /* printf("%s: HDELAY value is %d\n", bktr_name(bktr), temp); */ 3375 OUTB(bktr, BKTR_E_DELAY_LO, temp & 0xff); 3376 OUTB(bktr, BKTR_O_DELAY_LO, temp & 0xff); 3377 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xc); 3378 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xc); 3379 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 6) & 0xc)); 3380 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 6) & 0xc)); 3381 3382 /* vertical scale */ 3383 3384 if (bktr->capture_area_enabled) { 3385 if (bktr->flags & METEOR_ONLY_ODD_FIELDS || 3386 bktr->flags & METEOR_ONLY_EVEN_FIELDS) 3387 tmp_int = 65536 - 3388 (((bktr->capture_area_y_size * 256 + (bktr->rows/2)) / bktr->rows) - 512); 3389 else { 3390 tmp_int = 65536 - 3391 (((bktr->capture_area_y_size * 512 + (bktr->rows / 2)) / bktr->rows) - 512); 3392 } 3393 } else { 3394 if (bktr->flags & METEOR_ONLY_ODD_FIELDS || 3395 bktr->flags & METEOR_ONLY_EVEN_FIELDS) 3396 tmp_int = 65536 - 3397 (((fp->vactive * 256 + (bktr->rows/2)) / bktr->rows) - 512); 3398 else { 3399 tmp_int = 65536 - 3400 (((fp->vactive * 512 + (bktr->rows / 2)) / bktr->rows) - 512); 3401 } 3402 } 3403 3404 tmp_int &= 0x1fff; 3405 /* printf("%s: VSCALE value is %d\n", bktr_name(bktr), tmp_int); */ 3406 OUTB(bktr, BKTR_E_VSCALE_LO, tmp_int & 0xff); 3407 OUTB(bktr, BKTR_O_VSCALE_LO, tmp_int & 0xff); 3408 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x1f); 3409 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x1f); 3410 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | ((tmp_int >> 8) & 0x1f)); 3411 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | ((tmp_int >> 8) & 0x1f)); 3412 3413 3414 /* vertical active */ 3415 if (bktr->capture_area_enabled) 3416 temp = bktr->capture_area_y_size; 3417 else 3418 temp = fp->vactive; 3419 /* printf("%s: VACTIVE is %d\n", bktr_name(bktr), temp); */ 3420 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0x30); 3421 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 4) & 0x30)); 3422 OUTB(bktr, BKTR_E_VACTIVE_LO, temp & 0xff); 3423 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0x30); 3424 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 4) & 0x30)); 3425 OUTB(bktr, BKTR_O_VACTIVE_LO, temp & 0xff); 3426 3427 /* vertical delay */ 3428 if (bktr->capture_area_enabled) 3429 temp = fp->vdelay + (bktr->capture_area_y_offset); 3430 else 3431 temp = fp->vdelay; 3432 /* printf("%s: VDELAY is %d\n", bktr_name(bktr), temp); */ 3433 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) & ~0xC0); 3434 OUTB(bktr, BKTR_E_CROP, INB(bktr, BKTR_E_CROP) | ((temp >> 2) & 0xC0)); 3435 OUTB(bktr, BKTR_E_VDELAY_LO, temp & 0xff); 3436 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) & ~0xC0); 3437 OUTB(bktr, BKTR_O_CROP, INB(bktr, BKTR_O_CROP) | ((temp >> 2) & 0xC0)); 3438 OUTB(bktr, BKTR_O_VDELAY_LO, temp & 0xff); 3439 3440 /* end of video params */ 3441 3442 if ((bktr->xtal_pll_mode == BT848_USE_PLL) 3443 && (fp->iform_xtsel==BT848_IFORM_X_XT1)) { 3444 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_PLL); /* Select PLL mode */ 3445 } else { 3446 OUTB(bktr, BKTR_TGCTRL, BT848_TGCTRL_TGCKI_XTAL); /* Select Normal xtal 0/xtal 1 mode */ 3447 } 3448 3449 /* capture control */ 3450 switch (i_flag) { 3451 case 1: 3452 bktr->bktr_cap_ctl = 3453 (BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_EVEN); 3454 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20); 3455 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20); 3456 interlace = 1; 3457 break; 3458 case 2: 3459 bktr->bktr_cap_ctl = 3460 (BT848_CAP_CTL_DITH_FRAME | BT848_CAP_CTL_ODD); 3461 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) & ~0x20); 3462 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) & ~0x20); 3463 interlace = 1; 3464 break; 3465 default: 3466 bktr->bktr_cap_ctl = 3467 (BT848_CAP_CTL_DITH_FRAME | 3468 BT848_CAP_CTL_EVEN | BT848_CAP_CTL_ODD); 3469 OUTB(bktr, BKTR_E_VSCALE_HI, INB(bktr, BKTR_E_VSCALE_HI) | 0x20); 3470 OUTB(bktr, BKTR_O_VSCALE_HI, INB(bktr, BKTR_O_VSCALE_HI) | 0x20); 3471 interlace = 2; 3472 break; 3473 } 3474 3475 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); 3476 3477 rows = bktr->rows; 3478 cols = bktr->cols; 3479 3480 bktr->vbiflags &= ~VBI_CAPTURE; /* default - no vbi capture */ 3481 3482 /* RGB Grabs. If /dev/vbi is already open, or we are a PAL/SECAM */ 3483 /* user, then use the rgb_vbi RISC program. */ 3484 /* Otherwise, use the normal rgb RISC program */ 3485 if (pf_int->public.type == METEOR_PIXTYPE_RGB) { 3486 if ( (bktr->vbiflags & VBI_OPEN) 3487 ||(bktr->format_params == BT848_IFORM_F_PALBDGHI) 3488 ||(bktr->format_params == BT848_IFORM_F_SECAM) 3489 ){ 3490 bktr->bktr_cap_ctl |= 3491 BT848_CAP_CTL_VBI_EVEN | BT848_CAP_CTL_VBI_ODD; 3492 bktr->vbiflags |= VBI_CAPTURE; 3493 rgb_vbi_prog(bktr, i_flag, cols, rows, interlace); 3494 return; 3495 } else { 3496 rgb_prog(bktr, i_flag, cols, rows, interlace); 3497 return; 3498 } 3499 } 3500 3501 if ( pf_int->public.type == METEOR_PIXTYPE_YUV ) { 3502 yuv422_prog(bktr, i_flag, cols, rows, interlace); 3503 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0) 3504 | pixfmt_swap_flags( bktr->pixfmt )); 3505 return; 3506 } 3507 3508 if ( pf_int->public.type == METEOR_PIXTYPE_YUV_PACKED ) { 3509 yuvpack_prog(bktr, i_flag, cols, rows, interlace); 3510 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0) 3511 | pixfmt_swap_flags( bktr->pixfmt )); 3512 return; 3513 } 3514 3515 if ( pf_int->public.type == METEOR_PIXTYPE_YUV_12 ) { 3516 yuv12_prog(bktr, i_flag, cols, rows, interlace); 3517 OUTB(bktr, BKTR_COLOR_CTL, (INB(bktr, BKTR_COLOR_CTL) & 0xf0) 3518 | pixfmt_swap_flags( bktr->pixfmt )); 3519 return; 3520 } 3521 return; 3522 } 3523 3524 3525 /****************************************************************************** 3526 * video & video capture specific routines: 3527 */ 3528 3529 3530 /* 3531 * 3532 */ 3533 static void 3534 start_capture( bktr_ptr_t bktr, unsigned type ) 3535 { 3536 u_char i_flag; 3537 struct format_params *fp; 3538 3539 fp = &format_params[bktr->format_params]; 3540 3541 /* If requested, clear out capture buf first */ 3542 if (bktr->clr_on_start && (bktr->video.addr == 0)) { 3543 bzero((caddr_t)bktr->bigbuf, 3544 (size_t)bktr->rows * bktr->cols * bktr->frames * 3545 pixfmt_table[ bktr->pixfmt ].public.Bpp); 3546 } 3547 3548 OUTB(bktr, BKTR_DSTATUS, 0); 3549 OUTL(bktr, BKTR_INT_STAT, INL(bktr, BKTR_INT_STAT)); 3550 3551 bktr->flags |= type; 3552 bktr->flags &= ~METEOR_WANT_MASK; 3553 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 3554 case METEOR_ONLY_EVEN_FIELDS: 3555 bktr->flags |= METEOR_WANT_EVEN; 3556 i_flag = 1; 3557 break; 3558 case METEOR_ONLY_ODD_FIELDS: 3559 bktr->flags |= METEOR_WANT_ODD; 3560 i_flag = 2; 3561 break; 3562 default: 3563 bktr->flags |= METEOR_WANT_MASK; 3564 i_flag = 3; 3565 break; 3566 } 3567 3568 /* TDEC is only valid for continuous captures */ 3569 if ( type == METEOR_SINGLE ) { 3570 u_short fps_save = bktr->fps; 3571 3572 set_fps(bktr, fp->frame_rate); 3573 bktr->fps = fps_save; 3574 } 3575 else 3576 set_fps(bktr, bktr->fps); 3577 3578 if (bktr->dma_prog_loaded == FALSE) { 3579 build_dma_prog(bktr, i_flag); 3580 bktr->dma_prog_loaded = TRUE; 3581 } 3582 3583 3584 OUTL(bktr, BKTR_RISC_STRT_ADD, vtophys(bktr->dma_prog)); 3585 3586 } 3587 3588 3589 /* 3590 * 3591 */ 3592 static void 3593 set_fps( bktr_ptr_t bktr, u_short fps ) 3594 { 3595 struct format_params *fp; 3596 int i_flag; 3597 3598 fp = &format_params[bktr->format_params]; 3599 3600 switch(bktr->flags & METEOR_ONLY_FIELDS_MASK) { 3601 case METEOR_ONLY_EVEN_FIELDS: 3602 bktr->flags |= METEOR_WANT_EVEN; 3603 i_flag = 1; 3604 break; 3605 case METEOR_ONLY_ODD_FIELDS: 3606 bktr->flags |= METEOR_WANT_ODD; 3607 i_flag = 1; 3608 break; 3609 default: 3610 bktr->flags |= METEOR_WANT_MASK; 3611 i_flag = 2; 3612 break; 3613 } 3614 3615 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 3616 OUTL(bktr, BKTR_INT_STAT, ALL_INTS_CLEARED); 3617 3618 bktr->fps = fps; 3619 OUTB(bktr, BKTR_TDEC, 0); 3620 3621 if (fps < fp->frame_rate) 3622 OUTB(bktr, BKTR_TDEC, i_flag*(fp->frame_rate - fps) & 0x3f); 3623 else 3624 OUTB(bktr, BKTR_TDEC, 0); 3625 return; 3626 3627 } 3628 3629 3630 3631 3632 3633 /* 3634 * Given a pixfmt index, compute the bt848 swap_flags necessary to 3635 * achieve the specified swapping. 3636 * Note that without bt swapping, 2Bpp and 3Bpp modes are written 3637 * byte-swapped, and 4Bpp modes are byte and word swapped (see Table 6 3638 * and read R->L). 3639 * Note also that for 3Bpp, we may additionally need to do some creative 3640 * SKIPing to align the FIFO bytelines with the target buffer (see split()). 3641 * This is abstracted here: e.g. no swaps = RGBA; byte & short swap = ABGR 3642 * as one would expect. 3643 */ 3644 3645 static u_int pixfmt_swap_flags( int pixfmt ) 3646 { 3647 struct meteor_pixfmt *pf = &pixfmt_table[ pixfmt ].public; 3648 u_int swapf = 0; 3649 3650 switch ( pf->Bpp ) { 3651 case 2 : swapf = ( pf->swap_bytes ? 0 : BSWAP ); 3652 break; 3653 3654 case 3 : /* no swaps supported for 3bpp - makes no sense w/ bt848 */ 3655 break; 3656 3657 case 4 : if ( pf->swap_bytes ) 3658 swapf = pf->swap_shorts ? 0 : WSWAP; 3659 else 3660 swapf = pf->swap_shorts ? BSWAP : (BSWAP | WSWAP); 3661 break; 3662 } 3663 return swapf; 3664 } 3665 3666 3667 3668 /* 3669 * Converts meteor-defined pixel formats (e.g. METEOR_GEO_RGB16) into 3670 * our pixfmt_table indices. 3671 */ 3672 3673 static int oformat_meteor_to_bt( u_long format ) 3674 { 3675 int i; 3676 struct meteor_pixfmt *pf1, *pf2; 3677 3678 /* Find format in compatibility table */ 3679 for ( i = 0; i < METEOR_PIXFMT_TABLE_SIZE; i++ ) 3680 if ( meteor_pixfmt_table[i].meteor_format == format ) 3681 break; 3682 3683 if ( i >= METEOR_PIXFMT_TABLE_SIZE ) 3684 return -1; 3685 pf1 = &meteor_pixfmt_table[i].public; 3686 3687 /* Match it with an entry in master pixel format table */ 3688 for ( i = 0; i < PIXFMT_TABLE_SIZE; i++ ) { 3689 pf2 = &pixfmt_table[i].public; 3690 3691 if (( pf1->type == pf2->type ) && 3692 ( pf1->Bpp == pf2->Bpp ) && 3693 !bcmp( pf1->masks, pf2->masks, sizeof( pf1->masks )) && 3694 ( pf1->swap_bytes == pf2->swap_bytes ) && 3695 ( pf1->swap_shorts == pf2->swap_shorts )) 3696 break; 3697 } 3698 if ( i >= PIXFMT_TABLE_SIZE ) 3699 return -1; 3700 3701 return i; 3702 } 3703 3704 /****************************************************************************** 3705 * i2c primitives: 3706 */ 3707 3708 /* */ 3709 #define I2CBITTIME (0x5<<4) /* 5 * 0.48uS */ 3710 #define I2CBITTIME_878 (1 << 7) 3711 #define I2C_READ 0x01 3712 #define I2C_COMMAND (I2CBITTIME | \ 3713 BT848_DATA_CTL_I2CSCL | \ 3714 BT848_DATA_CTL_I2CSDA) 3715 3716 #define I2C_COMMAND_878 (I2CBITTIME_878 | \ 3717 BT848_DATA_CTL_I2CSCL | \ 3718 BT848_DATA_CTL_I2CSDA) 3719 3720 /* Select between old i2c code and new iicbus / smbus code */ 3721 #if defined(BKTR_USE_FREEBSD_SMBUS) 3722 3723 /* 3724 * The hardware interface is actually SMB commands 3725 */ 3726 int 3727 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 ) 3728 { 3729 char cmd; 3730 3731 if (bktr->id == BROOKTREE_848 || 3732 bktr->id == BROOKTREE_848A || 3733 bktr->id == BROOKTREE_849A) 3734 cmd = I2C_COMMAND; 3735 else 3736 cmd = I2C_COMMAND_878; 3737 3738 if (byte2 != -1) { 3739 if (smbus_writew(bktr->i2c_sc.smbus, addr, cmd, 3740 (short)(((byte2 & 0xff) << 8) | (byte1 & 0xff)))) 3741 return (-1); 3742 } else { 3743 if (smbus_writeb(bktr->i2c_sc.smbus, addr, cmd, 3744 (char)(byte1 & 0xff))) 3745 return (-1); 3746 } 3747 3748 /* return OK */ 3749 return( 0 ); 3750 } 3751 3752 int 3753 i2cRead( bktr_ptr_t bktr, int addr ) 3754 { 3755 char result; 3756 char cmd; 3757 3758 if (bktr->id == BROOKTREE_848 || 3759 bktr->id == BROOKTREE_848A || 3760 bktr->id == BROOKTREE_849A) 3761 cmd = I2C_COMMAND; 3762 else 3763 cmd = I2C_COMMAND_878; 3764 3765 if (smbus_readb(bktr->i2c_sc.smbus, addr, cmd, &result)) 3766 return (-1); 3767 3768 return ((int)((unsigned char)result)); 3769 } 3770 3771 #define IICBUS(bktr) ((bktr)->i2c_sc.iicbb) 3772 3773 /* The MSP34xx and DPL35xx Audio chip require i2c bus writes of up */ 3774 /* to 5 bytes which the bt848 automated i2c bus controller cannot handle */ 3775 /* Therefore we need low level control of the i2c bus hardware */ 3776 3777 /* Write to the MSP or DPL registers */ 3778 void 3779 msp_dpl_write(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr, unsigned int data) 3780 { 3781 unsigned char addr_l, addr_h, data_h, data_l ; 3782 3783 addr_h = (addr >>8) & 0xff; 3784 addr_l = addr & 0xff; 3785 data_h = (data >>8) & 0xff; 3786 data_l = data & 0xff; 3787 3788 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */); 3789 3790 iicbus_write_byte(IICBUS(bktr), dev, 0); 3791 iicbus_write_byte(IICBUS(bktr), addr_h, 0); 3792 iicbus_write_byte(IICBUS(bktr), addr_l, 0); 3793 iicbus_write_byte(IICBUS(bktr), data_h, 0); 3794 iicbus_write_byte(IICBUS(bktr), data_l, 0); 3795 3796 iicbus_stop(IICBUS(bktr)); 3797 3798 return; 3799 } 3800 3801 /* Read from the MSP or DPL registers */ 3802 unsigned int 3803 msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr) 3804 { 3805 unsigned int data; 3806 unsigned char addr_l, addr_h, dev_r; 3807 int read; 3808 u_char data_read[2]; 3809 3810 addr_h = (addr >>8) & 0xff; 3811 addr_l = addr & 0xff; 3812 dev_r = dev+1; 3813 3814 /* XXX errors ignored */ 3815 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */); 3816 3817 iicbus_write_byte(IICBUS(bktr), dev_r, 0); 3818 iicbus_write_byte(IICBUS(bktr), addr_h, 0); 3819 iicbus_write_byte(IICBUS(bktr), addr_l, 0); 3820 3821 iicbus_repeated_start(IICBUS(bktr), i2c_addr +1, 0 /* no timeout? */); 3822 iicbus_read(IICBUS(bktr), data_read, 2, &read, IIC_LAST_READ, 0); 3823 iicbus_stop(IICBUS(bktr)); 3824 3825 data = (data_read[0]<<8) | data_read[1]; 3826 3827 return (data); 3828 } 3829 3830 /* Reset the MSP or DPL chip */ 3831 /* The user can block the reset (which is handy if you initialise the 3832 * MSP and/or DPL audio in another operating system first (eg in Windows) 3833 */ 3834 void 3835 msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr ) 3836 { 3837 3838 #ifndef BKTR_NO_MSP_RESET 3839 /* put into reset mode */ 3840 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */); 3841 iicbus_write_byte(IICBUS(bktr), 0x00, 0); 3842 iicbus_write_byte(IICBUS(bktr), 0x80, 0); 3843 iicbus_write_byte(IICBUS(bktr), 0x00, 0); 3844 iicbus_stop(IICBUS(bktr)); 3845 3846 /* put back to operational mode */ 3847 iicbus_start(IICBUS(bktr), i2c_addr, 0 /* no timeout? */); 3848 iicbus_write_byte(IICBUS(bktr), 0x00, 0); 3849 iicbus_write_byte(IICBUS(bktr), 0x00, 0); 3850 iicbus_write_byte(IICBUS(bktr), 0x00, 0); 3851 iicbus_stop(IICBUS(bktr)); 3852 #endif 3853 return; 3854 } 3855 3856 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) { 3857 int read; 3858 3859 /* XXX errors ignored */ 3860 iicbus_start(IICBUS(bktr), bktr->remote_control_addr, 0 /* no timeout? */); 3861 iicbus_read(IICBUS(bktr), remote->data, 3, &read, IIC_LAST_READ, 0); 3862 iicbus_stop(IICBUS(bktr)); 3863 3864 return; 3865 } 3866 3867 #else /* defined(BKTR_USE_FREEBSD_SMBUS) */ 3868 3869 /* 3870 * Program the i2c bus directly 3871 */ 3872 int 3873 i2cWrite( bktr_ptr_t bktr, int addr, int byte1, int byte2 ) 3874 { 3875 u_long x; 3876 u_long data; 3877 3878 /* clear status bits */ 3879 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE); 3880 3881 /* build the command datum */ 3882 if (bktr->id == BROOKTREE_848 || 3883 bktr->id == BROOKTREE_848A || 3884 bktr->id == BROOKTREE_849A) { 3885 data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND; 3886 } else { 3887 data = ((addr & 0xff) << 24) | ((byte1 & 0xff) << 16) | I2C_COMMAND_878; 3888 } 3889 if ( byte2 != -1 ) { 3890 data |= ((byte2 & 0xff) << 8); 3891 data |= BT848_DATA_CTL_I2CW3B; 3892 } 3893 3894 /* write the address and data */ 3895 OUTL(bktr, BKTR_I2C_DATA_CTL, data); 3896 3897 /* wait for completion */ 3898 for ( x = 0x7fffffff; x; --x ) { /* safety valve */ 3899 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE ) 3900 break; 3901 } 3902 3903 /* check for ACK */ 3904 if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) ) 3905 return( -1 ); 3906 3907 /* return OK */ 3908 return( 0 ); 3909 } 3910 3911 3912 /* 3913 * 3914 */ 3915 int 3916 i2cRead( bktr_ptr_t bktr, int addr ) 3917 { 3918 u_long x; 3919 3920 /* clear status bits */ 3921 OUTL(bktr, BKTR_INT_STAT, BT848_INT_RACK | BT848_INT_I2CDONE); 3922 3923 /* write the READ address */ 3924 /* The Bt878 and Bt879 differed on the treatment of i2c commands */ 3925 3926 if (bktr->id == BROOKTREE_848 || 3927 bktr->id == BROOKTREE_848A || 3928 bktr->id == BROOKTREE_849A) { 3929 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND); 3930 } else { 3931 OUTL(bktr, BKTR_I2C_DATA_CTL, ((addr & 0xff) << 24) | I2C_COMMAND_878); 3932 } 3933 3934 /* wait for completion */ 3935 for ( x = 0x7fffffff; x; --x ) { /* safety valve */ 3936 if ( INL(bktr, BKTR_INT_STAT) & BT848_INT_I2CDONE ) 3937 break; 3938 } 3939 3940 /* check for ACK */ 3941 if ( !x || !(INL(bktr, BKTR_INT_STAT) & BT848_INT_RACK) ) 3942 return( -1 ); 3943 3944 /* it was a read */ 3945 return( (INL(bktr, BKTR_I2C_DATA_CTL) >> 8) & 0xff ); 3946 } 3947 3948 /* The MSP34xx Audio chip require i2c bus writes of up to 5 bytes which the */ 3949 /* bt848 automated i2c bus controller cannot handle */ 3950 /* Therefore we need low level control of the i2c bus hardware */ 3951 /* Idea for the following functions are from elsewhere in this driver and */ 3952 /* from the Linux BTTV i2c driver by Gerd Knorr <kraxel@cs.tu-berlin.de> */ 3953 3954 #define BITD 40 3955 static void i2c_start( bktr_ptr_t bktr) { 3956 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */ 3957 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */ 3958 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */ 3959 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */ 3960 } 3961 3962 static void i2c_stop( bktr_ptr_t bktr) { 3963 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */ 3964 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */ 3965 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */ 3966 } 3967 3968 static int i2c_write_byte( bktr_ptr_t bktr, unsigned char data) { 3969 int x; 3970 int status; 3971 3972 /* write out the byte */ 3973 for ( x = 7; x >= 0; --x ) { 3974 if ( data & (1<<x) ) { 3975 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 3976 DELAY( BITD ); /* assert HI data */ 3977 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); 3978 DELAY( BITD ); /* strobe clock */ 3979 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 3980 DELAY( BITD ); /* release clock */ 3981 } 3982 else { 3983 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 3984 DELAY( BITD ); /* assert LO data */ 3985 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); 3986 DELAY( BITD ); /* strobe clock */ 3987 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 3988 DELAY( BITD ); /* release clock */ 3989 } 3990 } 3991 3992 /* look for an ACK */ 3993 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */ 3994 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */ 3995 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */ 3996 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */ 3997 3998 return( status ); 3999 } 4000 4001 static int i2c_read_byte( bktr_ptr_t bktr, unsigned char *data, int last ) { 4002 int x; 4003 int bit; 4004 int byte = 0; 4005 4006 /* read in the byte */ 4007 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4008 DELAY( BITD ); /* float data */ 4009 for ( x = 7; x >= 0; --x ) { 4010 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); 4011 DELAY( BITD ); /* strobe clock */ 4012 bit = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the data bit */ 4013 if ( bit ) byte |= (1<<x); 4014 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4015 DELAY( BITD ); /* release clock */ 4016 } 4017 /* After reading the byte, send an ACK */ 4018 /* (unless that was the last byte, for which we send a NAK */ 4019 if (last) { /* send NAK - same a writing a 1 */ 4020 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4021 DELAY( BITD ); /* set data bit */ 4022 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); 4023 DELAY( BITD ); /* strobe clock */ 4024 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4025 DELAY( BITD ); /* release clock */ 4026 } else { /* send ACK - same as writing a 0 */ 4027 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 4028 DELAY( BITD ); /* set data bit */ 4029 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); 4030 DELAY( BITD ); /* strobe clock */ 4031 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 4032 DELAY( BITD ); /* release clock */ 4033 } 4034 4035 *data=byte; 4036 return 0; 4037 } 4038 #undef BITD 4039 4040 /* Write to the MSP or DPL registers */ 4041 void msp_dpl_write( bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr, 4042 unsigned int data){ 4043 unsigned int msp_w_addr = i2c_addr; 4044 unsigned char addr_l, addr_h, data_h, data_l ; 4045 addr_h = (addr >>8) & 0xff; 4046 addr_l = addr & 0xff; 4047 data_h = (data >>8) & 0xff; 4048 data_l = data & 0xff; 4049 4050 i2c_start(bktr); 4051 i2c_write_byte(bktr, msp_w_addr); 4052 i2c_write_byte(bktr, dev); 4053 i2c_write_byte(bktr, addr_h); 4054 i2c_write_byte(bktr, addr_l); 4055 i2c_write_byte(bktr, data_h); 4056 i2c_write_byte(bktr, data_l); 4057 i2c_stop(bktr); 4058 } 4059 4060 /* Read from the MSP or DPL registers */ 4061 unsigned int msp_dpl_read(bktr_ptr_t bktr, int i2c_addr, unsigned char dev, unsigned int addr){ 4062 unsigned int data; 4063 unsigned char addr_l, addr_h, data_1, data_2, dev_r ; 4064 addr_h = (addr >>8) & 0xff; 4065 addr_l = addr & 0xff; 4066 dev_r = dev+1; 4067 4068 i2c_start(bktr); 4069 i2c_write_byte(bktr,i2c_addr); 4070 i2c_write_byte(bktr,dev_r); 4071 i2c_write_byte(bktr,addr_h); 4072 i2c_write_byte(bktr,addr_l); 4073 4074 i2c_start(bktr); 4075 i2c_write_byte(bktr,i2c_addr+1); 4076 i2c_read_byte(bktr,&data_1, 0); 4077 i2c_read_byte(bktr,&data_2, 1); 4078 i2c_stop(bktr); 4079 data = (data_1<<8) | data_2; 4080 return data; 4081 } 4082 4083 /* Reset the MSP or DPL chip */ 4084 /* The user can block the reset (which is handy if you initialise the 4085 * MSP audio in another operating system first (eg in Windows) 4086 */ 4087 void msp_dpl_reset( bktr_ptr_t bktr, int i2c_addr ) { 4088 4089 #ifndef BKTR_NO_MSP_RESET 4090 /* put into reset mode */ 4091 i2c_start(bktr); 4092 i2c_write_byte(bktr, i2c_addr); 4093 i2c_write_byte(bktr, 0x00); 4094 i2c_write_byte(bktr, 0x80); 4095 i2c_write_byte(bktr, 0x00); 4096 i2c_stop(bktr); 4097 4098 /* put back to operational mode */ 4099 i2c_start(bktr); 4100 i2c_write_byte(bktr, i2c_addr); 4101 i2c_write_byte(bktr, 0x00); 4102 i2c_write_byte(bktr, 0x00); 4103 i2c_write_byte(bktr, 0x00); 4104 i2c_stop(bktr); 4105 #endif 4106 return; 4107 4108 } 4109 4110 static void remote_read(bktr_ptr_t bktr, struct bktr_remote *remote) { 4111 4112 /* XXX errors ignored */ 4113 i2c_start(bktr); 4114 i2c_write_byte(bktr,bktr->remote_control_addr); 4115 i2c_read_byte(bktr,&(remote->data[0]), 0); 4116 i2c_read_byte(bktr,&(remote->data[1]), 0); 4117 i2c_read_byte(bktr,&(remote->data[2]), 0); 4118 i2c_stop(bktr); 4119 4120 return; 4121 } 4122 4123 #endif /* defined(BKTR_USE_FREEBSD_SMBUS) */ 4124 4125 4126 #if defined( I2C_SOFTWARE_PROBE ) 4127 4128 /* 4129 * we are keeping this around for any parts that we need to probe 4130 * but that CANNOT be probed via an i2c read. 4131 * this is necessary because the hardware i2c mechanism 4132 * cannot be programmed for 1 byte writes. 4133 * currently there are no known i2c parts that we need to probe 4134 * and that cannot be safely read. 4135 */ 4136 static int i2cProbe( bktr_ptr_t bktr, int addr ); 4137 #define BITD 40 4138 #define EXTRA_START 4139 4140 /* 4141 * probe for an I2C device at addr. 4142 */ 4143 static int 4144 i2cProbe( bktr_ptr_t bktr, int addr ) 4145 { 4146 int x, status; 4147 4148 /* the START */ 4149 #if defined( EXTRA_START ) 4150 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release data */ 4151 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release clock */ 4152 #endif /* EXTRA_START */ 4153 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* lower data */ 4154 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock */ 4155 4156 /* write addr */ 4157 for ( x = 7; x >= 0; --x ) { 4158 if ( addr & (1<<x) ) { 4159 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4160 DELAY( BITD ); /* assert HI data */ 4161 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); 4162 DELAY( BITD ); /* strobe clock */ 4163 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); 4164 DELAY( BITD ); /* release clock */ 4165 } 4166 else { 4167 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 4168 DELAY( BITD ); /* assert LO data */ 4169 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); 4170 DELAY( BITD ); /* strobe clock */ 4171 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); 4172 DELAY( BITD ); /* release clock */ 4173 } 4174 } 4175 4176 /* look for an ACK */ 4177 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* float data */ 4178 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* strobe clock */ 4179 status = INL(bktr, BKTR_I2C_DATA_CTL) & 1; /* read the ACK bit */ 4180 OUTL(bktr, BKTR_I2C_DATA_CTL, 1); DELAY( BITD ); /* release clock */ 4181 4182 /* the STOP */ 4183 OUTL(bktr, BKTR_I2C_DATA_CTL, 0); DELAY( BITD ); /* lower clock & data */ 4184 OUTL(bktr, BKTR_I2C_DATA_CTL, 2); DELAY( BITD ); /* release clock */ 4185 OUTL(bktr, BKTR_I2C_DATA_CTL, 3); DELAY( BITD ); /* release data */ 4186 4187 return( status ); 4188 } 4189 #undef EXTRA_START 4190 #undef BITD 4191 4192 #endif /* I2C_SOFTWARE_PROBE */ 4193 4194 4195 #define ABSENT (-1) 4196