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