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