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