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