?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HAMMER 61E/Many: Stabilization, Performance
[dragonfly.git] / sys / dev / video / meteor / meteor.c
blob2fb6c5a4d102d2f0aba12ead1cf5901f0b59a21a
1 /*
2 * Copyright (c) 1995 Mark Tinguely and Jim Lowe
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Mark Tinguely and Jim Lowe
16 * 4. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
23 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 *
31 * $FreeBSD: src/sys/pci/meteor.c,v 1.49 1999/09/25 18:24:41 phk Exp $
32 * $DragonFly: src/sys/dev/video/meteor/meteor.c,v 1.22 2007/05/13 18:33:58 swildner Exp $
33 */
34
35 /* Change History:
36 8/21/95 Release
37 8/23/95 On advice from Stefan Esser, added volatile to PCI
38 memory pointers to remove PCI caching .
39 8/29/95 Fixes suggested by Bruce Evans.
40 meteor_mmap should return -1 on error rather than 0.
41 unit # > NMETEOR should be unit # >= NMETEOR.
42 10/24/95 Turn 50 Hz processing for SECAM and 60 Hz processing
43 off for AUTOMODE.
44 11/11/95 Change UV from always begin signed to ioctl selected
45 to either signed or unsigned.
46 12/07/95 Changed 7196 startup codes for 50 Hz as recommended
47 by Luigi Rizzo (luigi@iet.unipi.it)
48 12/08/95 Clear SECAM bit in PAL/NTSC and set input field count
49 bits for 50 Hz mode (PAL/SECAM) before I was setting the
50 output count bits. by Luigi Rizzo (luigi@iet.unipi.it)
51 12/18/95 Correct odd DMA field (never exceed, but good for safety
52 Changed 7196 startup codes for 50 Hz as recommended
53 by Luigi Rizzo (luigi@iet.unipi.it)
54 12/19/95 Changed field toggle mode to enable (offset 0x3c)
55 recommended by luigi@iet.unipi.it
56 Added in prototyping, include file, staticizing,
57 and DEVFS changes from FreeBSD team.
58 Changed the default allocated pages from 151 (NTSC)
59 to 217 (PAL).
60 Cleaned up some old comments in iic_write().
61 Added a Field (even or odd) only capture mode to
62 eliminate the high frequency problems with compression
63 algorithms. Recommended by luigi@iet.unipi.it.
64 Changed geometry ioctl so if it couldn't allocated a
65 large enough contiguous space, it wouldn't free the
66 stuff it already had.
67 Added new mode called YUV_422 which delivers the
68 data in planer Y followed by U followed by V. This
69 differs from the standard YUV_PACKED mode in that
70 the chrominance (UV) data is in the correct (different)
71 order. This is for programs like vic and mpeg_encode
72 so they don't have to reorder the chrominance data.
73 Added field count to stats.
74 Increment frame count stat if capturing continuous on
75 even frame grabs.
76 Added my email address to these comments
77 (james@cs.uwm.edu) suggested by (luigi@iet.unipt.it :-).
78 Changed the user mode signal mechanism to allow the
79 user program to be interrupted at the end of a frame
80 in any one of the modes. Added SSIGNAL ioctl.
81 Added a SFPS/GFPS ioctl so one may set the frames per
82 second that the card catpures. This code needs to be
83 completed.
84 Changed the interrupt routine so synchronous capture
85 will work on fields or frames and the starting frame
86 can be either even or odd.
87 Added HALT_N_FRAMES and CONT_N_FRAMES so one could
88 stop and continue synchronous capture mode.
89 Change the tsleep/wakeup function to wait on mtr
90 rather than &read_intr_wait.
91 1/22/96 Add option (METEOR_FreeBSD_210) for FreeBSD 2.1
92 to compile.
93 Changed intr so it only printed errors every 50 times.
94 Added unit number to error messages.
95 Added get_meteor_mem and enabled range checking.
96 1/30/96 Added prelim test stuff for direct video dma transfers
97 from Amancio Hasty (hasty@rah.star-gate.com). Until
98 we get some stuff sorted out, this will be ifdef'ed
99 with METEOR_DIRECT_VIDEO. This is very dangerous to
100 use at present since we don't check the address that
101 is passed by the user!!!!!
102 2/26/96 Added special SVIDEO input device type.
103 2/27/96 Added meteor_reg.h file and associate types Converted
104 meteor.c over to using meteor.h file. Prompted by
105 Lars Jonas Olsson <ljo@po.cwru.edu>.
106 2/28/96 Added meteor RGB code from Lars Jonas Olsson
107 <ljo@po.cwru.edu>. I make some mods to this code, so
108 I hope it still works as I don't have an rgb card to
109 test with.
110 2/29/96 <ljo@po.cwru.edu> tested the meteor RGB and supplied
111 me with diffs. Thanks, we now have a working RGB
112 version of the driver. Still need to clean up this
113 code.
114 3/1/96 Fixed a nasty little bug that was clearing the VTR
115 mode bit when the 7196 status was requested.
116 3/15/96 Fixed bug introduced in previous version that
117 stopped the only fields mode from working.
118 Added METEOR{GS}TS ioctl, still needs work.
119 3/25/96 Added YUV_9 and YUV_12 modes. Cleaned up some of the
120 code and converted variables to use the new register
121 types.
122 4/8/96 Fixed the a bug in with the range enable. Pointed
123 out by Jim Bray.
124 5/13/96 Fix the FPS ioctl so it actually sets the frames
125 per second. Code supplied by ian@robots.ox.ac.uk.
126 The new code implements a new define:
127 METEOR_SYSTEM_DEFAULT which should be defined as
128 METEOR_PAL, METEOR_SECAM, or METEOR_NTSC in your system
129 configuration file. If METEOR_SYSTEM_DEFAULT isn't
130 defined, and there is not a signal when set_fps is
131 called, then the call has no effect.
132 Changed the spelling of PLANER to PLANAR as pointed
133 out by Paco Hope <paco@cs.virigina.edu> and define
134 PLANER to be PLANAR for backward compatibility.
135 5/28/95 METEOR_INPUT_DEV_RCA -> METEOR_INPUT_DEV0, not
136 METEOR_GEO_DEV0. Pointed out by Ian Reid,
137 <ian@robots.ox.ac.uk>.
138 METEOR_DEV_MASK should be 0x0000f000 and not
139 0x2000f000, otherwise METEOR_RGB gets masked
140 out. Pointed out by Ian Reid.
141 Changed the fps code to give even distribution for
142 low frame rates. Code supplied by Ian Reid.
143 Fix some problems with the RGB version. Patch supplied
144 by <ljo@po.cwru.edu>.
145 Added METEOR_FIELD_MODE to include files for a
146 future version of this driver.
147 */
148
149 #include "use_meteor.h"
150 #include "opt_meteor.h"
151
152 #include <sys/param.h>
153 #include <sys/systm.h>
154 #include <sys/conf.h>
155 #include <sys/device.h>
156 #include <sys/kernel.h>
157 #include <sys/signalvar.h>
158 #include <sys/mman.h>
159 #include <sys/uio.h>
160
161 #if defined(METEOR_FreeBSD_210)
162 #include <machine/cpu.h> /* bootverbose */
163 #endif
164
165 #include <vm/vm.h>
166 #include <vm/vm_kern.h>
167 #include <vm/pmap.h>
168 #include <vm/vm_extern.h>
169
170 #include <bus/pci/pcivar.h>
171 #include <bus/pci/pcireg.h>
172 #include <dev/video/meteor/ioctl_meteor.h>
173 #include <dev/video/meteor/meteor_reg.h>
174
175
176 static void meteor_intr (void *arg);
177
178 /*
179 * Allocate enough memory for:
180 * 768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages
181 *
182 * You may override this using the options "METEOR_ALLOC_PAGES=value" in your
183 * kernel configuration file.
184 */
185 #ifndef METEOR_ALLOC_PAGES
186 #define METEOR_ALLOC_PAGES 217
187 #endif
188 #define METEOR_ALLOC (METEOR_ALLOC_PAGES * PAGE_SIZE)
189
190 static meteor_reg_t meteor[NMETEOR];
191 #define METEOR_NUM(mtr) ((mtr - &meteor[0])/sizeof(meteor_reg_t))
192
193 #define METPRI PCATCH
194
195 static const char* met_probe (pcici_t tag, pcidi_t type);
196 static void met_attach(pcici_t tag, int unit);
197 static u_long met_count;
198
199 static struct pci_device met_device = {
200 "meteor",
201 met_probe,
202 met_attach,
203 &met_count
204 };
205
206 COMPAT_PCI_DRIVER (meteor, met_device);
207
208 #if defined(METEOR_FreeBSD_210) /* XXX */
209 d_open_t meteor_open;
210 d_close_t meteor_close;
211 d_read_t meteor_read;
212 d_write_t meteor_write;
213 d_ioctl_t meteor_ioctl;
214 d_mmap_t meteor_mmap;
215 #else
216 static d_open_t meteor_open;
217 static d_close_t meteor_close;
218 static d_read_t meteor_read;
219 static d_write_t meteor_write;
220 static d_ioctl_t meteor_ioctl;
221 static d_mmap_t meteor_mmap;
222
223 #define CDEV_MAJOR 67
224 static struct dev_ops meteor_ops = {
225 { "meteor", CDEV_MAJOR, 0 },
226 .d_open = meteor_open,
227 .d_close = meteor_close,
228 .d_read = meteor_read,
229 .d_write = meteor_write,
230 .d_ioctl = meteor_ioctl,
231 .d_mmap = meteor_mmap,
232 };
233 #endif
234
235 static mreg_t saa7116_pci_default[sizeof(struct saa7116_regs)/sizeof(mreg_t)]={
236 /* PCI Memory registers */
237 /* BITS Type Description */
238 /* 0x00 */ 0x00000000, /* 31:1 e*RW DMA 1 (Even)
239 0 RO 0x0 */
240 /* 0x04 */ 0x00000000, /* 31:2 e*RW DMA 2 (Even)
241 1:0 RO 0x0 */
242 /* 0x08 */ 0x00000000, /* 31:2 e*RW DMA 3 (Even)
243 1:0 RO 0x0 */
244 /* 0x0c */ 0x00000000, /* 31:1 o*RW DMA 1 (Odd)
245 0 RO 0x0 */
246 /* 0x10 */ 0x00000000, /* 31:2 o*RW DMA 2 (Odd)
247 1:0 RO 0x0 */
248 /* 0x14 */ 0x00000000, /* 31:2 o*RW DMA 3 (Odd)
249 1:0 RO 0x0 */
250 /* 0x18 */ 0x00000500, /* 15:2 e*RW Stride 1 (Even)
251 1:0 RO 0x0 */
252 /* 0x1c */ 0x00000000, /* 15:2 e*RW Stride 2 (Even)
253 1:0 RO 0x0 */
254 /* 0x20 */ 0x00000000, /* 15:2 e*RW Stride 3 (Even)
255 1:0 RO 0x0 */
256 /* 0x24 */ 0x00000500, /* 15:2 o*RW Stride 1 (Odd)
257 1:0 RO 0x0 */
258 /* 0x28 */ 0x00000000, /* 15:2 o*RW Stride 2 (Odd)
259 1:0 RO 0x0 */
260 /* 0x2c */ 0x00000000, /* 15:2 o*RW Stride 3 (Odd)
261 1:0 RO 0x0 */
262 /* 0x30 */ 0xeeeeee01, /* 31:8 *RW Route (Even)
263 7:0 *RW Mode (Even) */
264 /* 0x34 */ 0xeeeeee01, /* 31:8 *RW Route (Odd)
265 7:0 *RW Mode (Odd) */
266 /* 0x38 */ 0x00200020, /* 22:16 *RW FIFO Trigger Planer Mode,
267 6:0 *RW FIFO Trigger Packed Mode */
268 /* 0x3c */ 0x00000107, /* 9:8 *RW Reserved (0x0)
269 2 *RW Field Toggle
270 1 *RW Reserved (0x1)
271 0 *RW Reserved (0x1) */
272 /* 0x40 */ 0x000000c0, /* 15 *RW Range Enable
273 14 *RW Corrupt Disable
274 11 *RR Address Error (Odd)
275 10 *RR Address Error (Even)
276 9 *RR Field Corrupt (Odd)
277 8 *RR Field Corrupt (Even)
278 7 *RW Fifo Enable
279 6 *RW VRSTN#
280 5 *RR Field Done (Odd)
281 4 *RR Field Done (Even)
282 3 *RS Single Field Capture (Odd)
283 2 *RS Single Field Capture (Even)
284 1 *RW Capture (ODD) Continous
285 0 *RW Capture (Even) Continous */
286 /* 0x44 */ 0x00000000, /* 7:0 *RW Retry Wait Counter */
287 /* 0x48 */ 0x00000307, /* 10 *RW Interrupt mask, start of field
288 9 *RW Interrupt mask, end odd field
289 8 *RW Interrupt mask, end even field
290 2 *RR Interrupt status, start of field
291 1 *RR Interrupt status, end of odd
292 0 *RR Interrupt status, end of even */
293 /* 0x4c */ 0x00000001, /* 31:0 *RW Field Mask (Even) continous */
294 /* 0x50 */ 0x00000001, /* 31:0 *RW Field Mask (Odd) continous */
295 /* 0x54 */ 0x00000000, /* 20:16 *RW Mask Length (Odd)
296 4:0 *RW Mask Length (Even) */
297 /* 0x58 */ 0x0005007c, /* 22:16 *RW FIFO almost empty
298 6:0 *RW FIFO almost full */
299 /* 0x5c */ 0x461e1e0f, /* 31:24 *RW I2C Phase 4
300 23:16 *RW I2C Phase 3
301 15:8 *RW I2C Phase 2
302 7:0 *RW I2C Phase 1 */
303 /* 0x60 */ 0x00000300, /* 31:24 *RO I2C Read Data
304 23:16 **RW I2C Auto Address
305 11 RO I2C SCL Input
306 10 RO I2C SDA Input
307 9 RR I2C Direct Abort
308 8 RR I2C Auto Abort
309 3 RW I2C SCL Output
310 2 RW I2C SDA Output
311 1 RW I2C Bypass
312 0 RW I2C Auto Enable */
313 /* 0x64 */ 0x00000000, /* 24 RS I2C New Cycle
314 23:16 **RW I2C Direct Address
315 15:8 **RW I2C Direct Sub-address
316 7:0 **RW I2C Direct Write Address */
317 /* 0x68 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 1 (Even)
318 23:16 **RW I2C Auto Data 1 (Even)
319 15:8 **RW I2C Auto Sub-address 0 (Even)
320 7:0 **RW I2C Auto Data 0 (Even) */
321 /* 0x6c */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 3 (Even)
322 23:16 **RW I2C Auto Data 3 (Even)
323 15:8 **RW I2C Auto Sub-address 2 (Even)
324 7:0 **RW I2C Auto Data 2 (Even) */
325 /* 0x70 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 5 (Even)
326 23:16 **RW I2C Auto Data 5 (Even)
327 15:8 **RW I2C Auto Sub-address 4 (Even)
328 7:0 **RW I2C Auto Data 4 (Even) */
329 /* 0x74 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 7 (Even)
330 23:16 **RW I2C Auto Data 7 (Even)
331 15:8 **RW I2C Auto Sub-address 6 (Even)
332 7:0 **RW I2C Auto Data 6 (Even) */
333 /* 0x78 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 1 (Odd)
334 23:16 **RW I2C Auto Data 1 (Odd)
335 15:8 **RW I2C Auto Sub-address 0 (Odd)
336 7:0 **RW I2C Auto Data 0 (Odd) */
337 /* 0x7c */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 3 (Odd)
338 23:16 **RW I2C Auto Data 3 (Odd)
339 15:8 **RW I2C Auto Sub-address 2 (Odd)
340 7:0 **RW I2C Auto Data 2 (Odd) */
341 /* 0x80 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 5 (Odd)
342 23:16 **RW I2C Auto Data 5 (Odd)
343 15:8 **RW I2C Auto Sub-address 4 (Odd)
344 7:0 **RW I2C Auto Data 4 (Odd) */
345 /* 0x84 */ 0x00000000, /* 31:24 **RW I2C Auto Sub-address 7 (Odd)
346 23:16 **RW I2C Auto Data 7 (Odd)
347 15:8 **RW I2C Auto Sub-address 6 (Odd)
348 7:0 **RW I2C Auto Data 6 (Odd) */
349 /* 0x88 */ 0x00000000, /* 23:16 **RW I2C Register Enable (Odd)
350 7:0 **RW I2C Register Enable (Even) */
351 /* 0x8c */ 0x00000000, /* 23:2 e*RW DMA End (Even)
352 1:0 RO 0x0 */
353 /* 0x90 */ 0x00000000 /* 23:2 e*RW DMA End (Odd)
354 1:0 RO 0x0 */
355 };
356
357 static u_char saa7196_i2c_default[NUM_SAA7196_I2C_REGS] = {
358 /* SAA7196 I2C bus control */
359 /* BITS Function */
360 /* 00 */ 0x50, /* 7:0 Increment Delay */
361 /* 01 */ 0x30, /* 7:0 Horizontal Sync Begin for 50hz */
362 /* 02 */ 0x00, /* 7:0 Horizontal Sync Stop for 50hz */
363 /* 03 */ 0xe8, /* 7:0 Horizontal Sync Clamp Start for 50hz */
364 /* 04 */ 0xb6, /* 7:0 Horizontal Sync Clamp Stop for 50hz */
365 /* 05 */ 0xf4, /* 7:0 Horizontal Sync Start after PH1 for 50hz */
366 /* 06 */ 0x46, /* 7 Input mode =0 CVBS, =1 S-Video
367 6 Pre filter
368 5:4 Aperture Bandpass characteristics
369 3:2 Coring range for high freq
370 1:0 Aperture bandpass filter weights */
371 /* 07 */ 0x00, /* 7:0 Hue */
372 /* 08 */ 0x7f, /* 7:3 Colour-killer threshold QAM (PAL, NTSC) */
373 /* 09 */ 0x7f, /* 7:3 Colour-killer threshold SECAM */
374 /* 0a */ 0x7f, /* 7:0 PAL switch sensitivity */
375 /* 0b */ 0x7f, /* 7:0 SECAM switch sensitivity */
376 /* 0c */ 0x40, /* 7 Colour-on bit
377 6:5 AGC filter */
378 /* 0d */ 0x84, /* 7 VTR/TV mode bit = 1->VTR mode
379 3 Realtime output mode select bit
380 2 HREF position select
381 1 Status byte select
382 0 SECAM mode bit */
383 /* 0e */ 0x38, /* 7 Horizontal clock PLL
384 5 Select interal/external clock source
385 4 Output enable of Horizontal/Vertical sync
386 3 Data output YUV enable
387 2 S-VHS bit
388 1 GPSW2
389 0 GPSW1 */
390 /* 0f */ 0x50, /* 7 Automatic Field detection
391 6 Field Select 0 = 50hz, 1=60hz
392 5 SECAM cross-colour reduction
393 4 Enable sync and clamping pulse
394 3:1 Luminance delay compensation */
395 /* 10 */ 0x00, /* 2 Select HREF Position
396 1:0 Vertical noise reduction */
397 /* 11 */ 0x2c, /* 7:0 Chrominance gain conrtol for QAM */
398 /* 12 */ 0x40, /* 7:0 Chrominance saturation control for VRAM port */
399 /* 13 */ 0x40, /* 7:0 Luminance contract control for VRAM port */
400 /* 14 */ 0x34, /* 7:0 Horizontal sync begin for 60hz */
401 #ifdef notdef
402 /* 15 */ 0x0c, /* 7:0 Horizontal sync stop for 60hz */
403 /* 16 */ 0xfb, /* 7:0 Horizontal clamp begin for 60hz */
404 /* 17 */ 0xd4, /* 7:0 Horizontal clamp stop for 60hz */
405 /* 18 */ 0xec, /* 7:0 Horizontal sync start after PH1 for 60hz */
406 #else
407 0x0a, 0xf4, 0xce, 0xf4,
408 #endif
409 /* 19 */ 0x80, /* 7:0 Luminance brightness control for VRAM port */
410 /* 1a */ 0x00,
411 /* 1b */ 0x00,
412 /* 1c */ 0x00,
413 /* 1d */ 0x00,
414 /* 1e */ 0x00,
415 /* 1f */ 0x00,
416 /* 20 */ 0x90, /* 7 ROM table bypass switch
417 6:5 Set output field mode
418 4 VRAM port outputs enable
419 3:2 First pixel position in VRO data
420 1:0 FIFO output register select */
421 /* 21 */ 0x80, /* 7:0 [7:0] Pixel number per line on output */
422 /* 22 */ 0x80, /* 7:0 [7:0] Pixel number per line on input */
423 /* 23 */ 0x03, /* 7:0 [7:0] Horizontal start position of scaling win*/
424 /* 24 */ 0x8a, /* 7:5 Horizontal decimation filter
425 4 [8] Horizontal start position of scaling win
426 3:2 [9:8] Pixel number per line on input
427 1:0 [9:8] Pixel number per line on output */
428 /* 25 */ 0xf0, /* 7:0 [7:0] Line number per output field */
429 /* 26 */ 0xf0, /* 7:0 [7:0] Line number per input field */
430 /* 27 */ 0x0f, /* 7:0 [7:0] Vertical start of scaling window */
431 /* 28 */ 0x80, /* 7 Adaptive filter switch
432 6:5 Vertical luminance data processing
433 4 [8] Vertical start of scaling window
434 3:2 [9:8] Line number per input field
435 1:0 [9:8] Line number per output field */
436 /* 29 */ 0x16, /* 7:0 [7:0] Vertical bypass start */
437 /* 2a */ 0x00, /* 7:0 [7:0] Vertical bypass count */
438 /* 2b */ 0x00, /* 4 [8] Vertical bypass start
439 2 [8] Vertical bypass count
440 0 Polarity, internally detected odd even flag */
441 /* 2c */ 0x80, /* 7:0 Set lower limit V for colour-keying */
442 /* 2d */ 0x7f, /* 7:0 Set upper limit V for colour-keying */
443 /* 2e */ 0x80, /* 7:0 Set lower limit U for colour-keying */
444 /* 2f */ 0x7f, /* 7:0 Set upper limit U for colour-keying */
445 /* 30 */ 0xbf /* 7 VRAM bus output format
446 6 Adaptive geometrical filter
447 5 Luminance limiting value
448 4 Monochrome and two's complement output data sel
449 3 Line quailifier flag
450 2 Pixel qualifier flag
451 1 Transparent data transfer
452 0 Extended formats enable bit */
453 };
454
455 static u_char bt254_default[NUM_BT254_REGS] = {
456 0x00, /* 24 bpp */
457 0xa0,
458 0xa0,
459 0xa0,
460 0x50,
461 0x50,
462 0x50,
463 } ;
464
465 /*
466 * i2c_write:
467 * Returns 0 Succesful completion.
468 * Returns 1 If transfer aborted or timeout occured.
469 *
470 */
471 static int i2c_print_err = 1;
472 static int
473 i2c_write(meteor_reg_t * mtr, u_char slave, u_char rw, u_char reg, u_char data)
474 {
475 unsigned long wait_counter = 0x0001ffff;
476 mreg_t * iic_write_loc = &mtr->base->i2c_write;
477 int err = 0;
478
479
480 /* Write the data the the i2c write register */
481 *iic_write_loc = SAA7116_IIC_NEW_CYCLE |
482 (((u_long)slave|(u_long)rw) << 16) |
483 ((u_long)reg << 8) | (u_long)data;
484
485 /* Wait until the i2c cycle is compeleted */
486 while((*iic_write_loc & SAA7116_IIC_NEW_CYCLE)) {
487 if(!wait_counter) break;
488 wait_counter--;
489 }
490
491 /* 1ffff should be enough delay time for the i2c cycle to complete */
492 if(!wait_counter) {
493 if(i2c_print_err)
494 kprintf("meteor%d: %d i2c %s transfer timeout 0x%x",
495 METEOR_NUM(mtr), slave,
496 rw ? "read" : "write", *iic_write_loc);
497
498 err=1;
499 }
500
501 /* Check for error on direct write, clear if any */
502 if(mtr->base->i2c_read & SAA7116_IIC_DIRECT_TRANSFER_ABORTED){
503 mtr->base->i2c_read |= SAA7116_IIC_DIRECT_TRANSFER_ABORTED;
504 if(i2c_print_err)
505 kprintf("meteor%d: 0x%x i2c %s transfer aborted",
506 METEOR_NUM(mtr), slave,
507 rw ? "read" : "write" );
508 err= 1;
509 }
510
511 if(err) {
512 if(i2c_print_err)
513 kprintf(" - reg=0x%x, value=0x%x.\n", reg, data);
514 }
515
516 return err;
517 }
518 #undef i2c_print
519
520 static const char *
521 met_probe (pcici_t tag, pcidi_t type)
522 {
523 switch (type) {
524 case SAA7116_PHILIPS_ID: /* meteor */
525 return("Philips SAA 7116");
526 };
527 return ((char *)0);
528 }
529
530 /* interrupt handling routine
531 complete meteor_read() if using interrupts
532 */
533 static void
534 meteor_intr(void *arg)
535 {
536 meteor_reg_t *mtr = (meteor_reg_t *) arg;
537 mreg_t *cap = &mtr->base->cap_cntl,
538 *base = &mtr->base->dma1e,
539 *stat = &mtr->base->irq_stat;
540 u_long status = *stat,
541 cap_err = *cap & 0x00000f00,
542 #ifdef METEOR_CHECK_PCI_BUS
543 pci_err = pci_conf_read(mtr->tag,
544 PCI_COMMAND_STATUS_REG),
545 #endif
546 next_base = (u_long)(vtophys(mtr->bigbuf));
547
548 /*
549 * Disable future interrupts if a capture mode is not selected.
550 * This can happen when we are in the process of closing or
551 * changing capture modes, otherwise it shouldn't happen.
552 */
553 if(!(mtr->flags & METEOR_CAP_MASK)) {
554 *cap &= 0x8ff0; /* disable future interrupts */
555 }
556 #ifdef METEOR_CHECK_PCI_BUS
557 /*
558 * Check for pci bus errors.
559 */
560 #define METEOR_MASTER_ABORT 0x20000000
561 #define METEOR_TARGET_ABORT 0x10000000
562 if(pci_err & METEOR_MASTER_ABORT) {
563 kprintf("meteor%d: intr: pci bus master dma abort: 0x%x 0x%x.\n",
564 METEOR_NUM(mtr), *base, *(base+3));
565 pci_conf_write(mtr->tag, PCI_COMMAND_STATUS_REG, pci_err);
566 }
567 if(pci_err & METEOR_TARGET_ABORT) {
568 kprintf("meteor%d: intr: pci bus target dma abort: 0x%x 0x%x.\n",
569 METEOR_NUM(mtr), *base, *(base+3));
570 pci_conf_write(mtr->tag, PCI_COMMAND_STATUS_REG, pci_err);
571 }
572 #endif
573 /*
574 * Check for errors.
575 */
576 if (cap_err) {
577 if (cap_err & 0x300) {
578 if(mtr->fifo_errors % 50 == 0) {
579 kprintf("meteor%d: capture error", METEOR_NUM(mtr));
580 kprintf(": %s FIFO overflow.\n",
581 cap_err&0x0100? "even" : "odd");
582 }
583 mtr->fifo_errors++ ; /* increment fifo capture errors cnt */
584 }
585 if (cap_err & 0xc00) {
586 if(mtr->dma_errors % 50 == 0) {
587 kprintf("meteor%d: capture error", METEOR_NUM(mtr));
588 kprintf(": %s DMA address.\n",
589 cap_err&0x0400? "even" : "odd");
590 }
591 mtr->dma_errors++ ; /* increment DMA capture errors cnt */
592 }
593 }
594 *cap |= 0x0f30; /* clear error and field done */
595
596 /*
597 * In synchronous capture mode we need to know what the address
598 * offset for the next field/frame will be. next_base holds the
599 * value for the even dma buffers (for odd, one must add stride).
600 */
601 if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait &&
602 (mtr->current < mtr->frames)) { /* could be !=, but < is safer */
603 /* next_base is initialized to mtr->bigbuf */
604 next_base += mtr->frame_size * mtr->current;
605 if(mtr->flags & METEOR_WANT_TS)
606 next_base += sizeof(struct timeval) * mtr->current;
607 }
608
609 /*
610 * Count the field and clear the field flag.
611 *
612 * In single mode capture, clear the continuous capture mode.
613 *
614 * In synchronous capture mode, if we have room for another field,
615 * adjust DMA buffer pointers.
616 * When we are above the hi water mark (hiwat), mtr->synch_wait will
617 * be set and we will not bump the DMA buffer pointers. Thus, once
618 * we reach the hi water mark, the driver acts like a continuous mode
619 * capture on the mtr->current frame until we hit the low water
620 * mark (lowat). The user had the option of stopping or halting
621 * the capture if this is not the desired effect.
622 */
623 if (status & 0x1) { /* even field */
624 mtr->even_fields_captured++;
625 mtr->flags &= ~METEOR_WANT_EVEN;
626 if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait) {
627 *base = next_base;
628 /* XXX should add adjustments for YUV_422 & PLANAR */
629 }
630 /*
631 * If the user requested to be notified via signal,
632 * let them know the field is complete.
633 */
634 if(mtr->proc && (mtr->signal & METEOR_SIG_MODE_MASK))
635 ksignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
636 }
637 if (status & 0x2) { /* odd field */
638 mtr->odd_fields_captured++;
639 mtr->flags &= ~METEOR_WANT_ODD;
640 if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait) {
641 *(base+3) = next_base + *(base+6);
642 /* XXX should add adjustments for YUV_422 & PLANAR */
643 }
644 /*
645 * If the user requested to be notified via signal,
646 * let them know the field is complete.
647 */
648 if(mtr->proc && (mtr->signal & METEOR_SIG_MODE_MASK))
649 ksignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
650 }
651
652 /*
653 * If we have a complete frame.
654 */
655 if(!(mtr->flags & METEOR_WANT_MASK)) {
656 mtr->frames_captured++;
657 /*
658 * post the completion time.
659 */
660 if(mtr->flags & METEOR_WANT_TS) {
661 struct timeval *ts;
662
663 if(mtr->alloc_pages * PAGE_SIZE <= (mtr->frame_size +
664 sizeof(struct timeval))) {
665 ts =(struct timeval *)mtr->bigbuf +
666 mtr->frame_size;
667 /* doesn't work in synch mode except for first frame */
668 /* XXX */
669 microtime(ts);
670 }
671 }
672 /*
673 * Wake up the user in single capture mode.
674 */
675 if(mtr->flags & METEOR_SINGLE)
676 wakeup((caddr_t)mtr);
677 /*
678 * If the user requested to be notified via signal,
679 * let them know the frame is complete.
680 */
681 if(mtr->proc && !(mtr->signal & METEOR_SIG_MODE_MASK))
682 ksignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
683 /*
684 * Reset the want flags if in continuous or
685 * synchronous capture mode.
686 */
687 if(mtr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
688 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
689 case METEOR_ONLY_ODD_FIELDS:
690 mtr->flags |= METEOR_WANT_ODD;
691 break;
692 case METEOR_ONLY_EVEN_FIELDS:
693 mtr->flags |= METEOR_WANT_EVEN;
694 break;
695 default:
696 mtr->flags |= METEOR_WANT_MASK;
697 break;
698 }
699 }
700 /*
701 * Special handling for synchronous capture mode.
702 */
703 if(mtr->flags & METEOR_SYNCAP) {
704 struct meteor_mem *mm = mtr->mem;
705 /*
706 * Mark the current frame as active. It is up to
707 * the user to clear this, but we will clear it
708 * for the user for the current frame being captured
709 * if we are within the water marks (see below).
710 */
711 mm->active |= 1 << (mtr->current - 1);
712
713 /*
714 * Since the user can muck with these values, we need
715 * to check and see if they are sane. If they don't
716 * pass the sanity check, disable the capture mode.
717 * This is rather rude, but then so was the user.
718 *
719 * Do we really need all of this or should we just
720 * eliminate the possiblity of allowing the
721 * user to change hi and lo water marks while it
722 * is running? XXX
723 */
724 if(mm->num_active_bufs < 0 ||
725 mm->num_active_bufs > mtr->frames ||
726 mm->lowat < 1 || mm->lowat >= mtr->frames ||
727 mm->hiwat < 1 || mm->hiwat >= mtr->frames ||
728 mm->lowat > mm->hiwat ) {
729 *cap &= 0x8ff0;
730 mtr->flags &= ~(METEOR_SYNCAP|METEOR_WANT_MASK);
731 } else {
732 /*
733 * Ok, they are sane, now we want to
734 * check the water marks.
735 */
736 if(mm->num_active_bufs <= mm->lowat)
737 mtr->synch_wait = 0;
738 if(mm->num_active_bufs >= mm->hiwat)
739 mtr->synch_wait = 1;
740 /*
741 * Clear the active frame bit for this frame
742 * and advance the counters if we are within
743 * the banks of the water marks.
744 */
745 if(!mtr->synch_wait) {
746 mm->active &= ~(1 << mtr->current);
747 mtr->current++;
748 if(mtr->current > mtr->frames)
749 mtr->current = 1;
750 mm->num_active_bufs++;
751 }
752 }
753 }
754 }
755
756 *stat |= 0x7; /* clear interrupt status */
757 return;
758 }
759
760 static void
761 set_fps(meteor_reg_t *mtr, u_short fps)
762 {
763 struct saa7116_regs *s7116 = mtr->base;
764 unsigned status;
765 unsigned maxfps, mask = 0x1, length = 0;
766
767 SAA7196_WRITE(mtr, SAA7196_STDC, SAA7196_REG(mtr, SAA7196_STDC) | 0x02);
768 SAA7196_READ(mtr);
769 status = (s7116->i2c_read & 0xff000000L) >> 24;
770
771 /*
772 * Determine if there is an input signal. Depending on the
773 * frequency we either have a max of 25 fps (50 hz) or 30 fps (60 hz).
774 * If there is no input signal, then we need some defaults. If the
775 * user neglected to specify any defaults, just set to the fps to max.
776 */
777 if((status & 0x40) == 0) { /* Is there a signal ? */
778 if(status & 0x20) {
779 maxfps = 30; /* 60 hz system */
780 } else {
781 maxfps = 25; /* 50 hz system */
782 }
783 } else { /* We have no signal, check defaults */
784 #if METEOR_SYSTEM_DEFAULT == METEOR_PAL || METEOR_SYSTEM_DEFAULT == METEOR_SECAM
785 maxfps = 25;
786 #elif METEOR_SYSTEM_DEFAULT == METEOR_NTSC
787 maxfps = 30;
788 #else
789 /* Don't really know what to do, just set max */
790 maxfps = 30;
791 fps = 30;
792 #endif
793 }
794
795 /*
796 * A little sanity checking...
797 */
798 if(fps < 1) fps = 1;
799 if(fps > maxfps) fps = maxfps;
800
801 /*
802 * Compute the mask/length using the fps.
803 */
804 if(fps == maxfps) {
805 mask = 0x1;
806 length = 0x0;
807 } else if ((float)fps == maxfps/2.0) {
808 mask = 0x1;
809 length = 0x1;
810 } else if (fps > maxfps/2) {
811 float step, b;
812
813 mask = (1<<maxfps) - 1;
814 length = maxfps - 1;
815 step = (float)(maxfps - 1)/(float)(maxfps - fps);
816 for(b=step; b < maxfps; b += step) {
817 mask &= ~(1<<((int)b)); /* mask out the bth frame */
818 }
819 } else { /* fps < maxfps/2 */
820 float step, b;
821
822 mask = 0x1;
823 length = maxfps - 1;
824 step = (float)(maxfps -1)/(float)(fps);
825 for(b = step + 1; b < maxfps - 1; b += step) {
826 mask |= (1<<((int)b)); /* mask in the bth frame */
827 }
828 }
829
830 /*
831 * Set the fps.
832 */
833 s7116->fme = s7116->fmo = mask;
834 s7116->fml = (length << 16) | length;
835
836 mtr->fps = fps;
837
838 return;
839
840 }
841
842 /*
843 * There is also a problem with range checking on the 7116.
844 * It seems to only work for 22 bits, so the max size we can allocate
845 * is 22 bits long or 4194304 bytes assuming that we put the beginning
846 * of the buffer on a 2^24 bit boundary. The range registers will use
847 * the top 8 bits of the dma start registers along with the bottom 22
848 * bits of the range register to determine if we go out of range.
849 * This makes getting memory a real kludge.
850 *
851 */
852 #define RANGE_BOUNDARY (1<<22)
853 static vm_offset_t
854 get_meteor_mem(int unit, unsigned size)
855 {
856 vm_offset_t addr = 0;
857
858 addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24);
859 if(addr == 0)
860 addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE);
861 if(addr == 0) {
862 kprintf("meteor%d: Unable to allocate %d bytes of memory.\n",
863 unit, size);
864 }
865
866 return addr;
867 }
868
869 static void
870 bt254_write(meteor_reg_t *mtr, u_char addr, u_char data)
871 {
872 addr &= 0x7; /* sanity? */
873 mtr->bt254_reg[addr] = data;
874 PCF8574_DATA_WRITE(mtr, data); /* set data */
875 PCF8574_CTRL_WRITE(mtr, (PCF8574_CTRL_REG(mtr) & ~0x7) | addr);
876 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x10); /* WR/ to 0 */
877 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x10); /* WR to 1 */
878 PCF8574_DATA_WRITE(mtr, 0xff); /* clr data */
879
880 }
881
882 static void
883 bt254_init(meteor_reg_t *mtr)
884 {
885 int i;
886
887 PCF8574_CTRL_WRITE(mtr, 0x7f);
888 PCF8574_DATA_WRITE(mtr, 0xff); /* data port must be 0xff */
889 PCF8574_CTRL_WRITE(mtr, 0x7f);
890
891 /* init RGB module for 24bpp, composite input */
892 for(i=0; i<NUM_BT254_REGS; i++)
893 bt254_write(mtr, i, bt254_default[i]);
894
895 bt254_write(mtr, BT254_COMMAND, 0x00); /* 24 bpp */
896 }
897
898 static void
899 bt254_ntsc(meteor_reg_t *mtr, int arg)
900 {
901 if (arg){
902 /* Set NTSC bit */
903 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x20);
904 }
905 else {
906 /* reset NTSC bit */
907 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) &= ~0x20);
908 }
909 }
910
911 static void
912 select_bt254(meteor_reg_t *mtr)
913 {
914 /* disable saa7196, saaen = 1 */
915 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x80);
916 /* enable Bt254, bten = 0 */
917 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x40);
918 }
919
920 static void
921 select_saa7196(meteor_reg_t *mtr)
922 {
923 /* disable Bt254, bten = 1 */
924 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x40);
925 /* enable saa7196, saaen = 0 */
926 PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x80);
927 }
928
929 /*
930 * Initialize the 7116, 7196 and the RGB module.
931 */
932 static void
933 meteor_init ( meteor_reg_t *mtr )
934 {
935 mreg_t *vbase_addr;
936 int i;
937
938 /*
939 * Initialize the Philips SAA7116
940 */
941 mtr->base->cap_cntl = 0x00000040L;
942 vbase_addr = &mtr->base->dma1e;
943 for (i = 0 ; i < (sizeof(struct saa7116_regs)/sizeof(mreg_t)); i++)
944 *vbase_addr++ = saa7116_pci_default[i];
945
946 /*
947 * Check for the Philips SAA7196
948 */
949 i2c_print_err = 0;
950 if(i2c_write(mtr, SAA7196_I2C_ADDR, SAA7116_I2C_WRITE, 0, 0xff) == 0) {
951 i2c_print_err = 1;
952 /*
953 * Initialize 7196
954 */
955 for (i = 0; i < NUM_SAA7196_I2C_REGS; i++)
956 SAA7196_WRITE(mtr, i, saa7196_i2c_default[i]);
957 /*
958 * Get version number.
959 */
960 SAA7196_WRITE(mtr, SAA7196_STDC,
961 SAA7196_REG(mtr, SAA7196_STDC) & ~0x02);
962 SAA7196_READ(mtr);
963 kprintf("meteor%d: <Philips SAA 7196> rev 0x%x\n",
964 METEOR_NUM(mtr),
965 (unsigned)((mtr->base->i2c_read & 0xff000000L) >> 28));
966 } else {
967 i2c_print_err = 1;
968 kprintf("meteor%d: <Philips SAA 7196 NOT FOUND>\n",
969 METEOR_NUM(mtr));
970 }
971 /*
972 * Check for RGB module, initialized if found.
973 */
974 i2c_print_err = 0;
975 if(i2c_write(mtr,PCF8574_DATA_I2C_ADDR,SAA7116_I2C_WRITE,0,0xff) == 0) {
976 i2c_print_err = 1;
977 kprintf("meteor%d: <Booktree 254 (RGB module)>\n",
978 METEOR_NUM(mtr)); /* does this have a rev #? */
979 bt254_init(mtr); /* Set up RGB module */
980 mtr->flags = METEOR_RGB;
981 } else {
982 i2c_print_err = 1;
983 mtr->flags = 0;
984 }
985
986 set_fps(mtr, 30);
987
988 }
989
990 static void
991 met_attach(pcici_t tag, int unit)
992 {
993 #ifdef METEOR_IRQ
994 u_long old_irq, new_irq;
995 #endif /* METEOR_IRQ */
996 meteor_reg_t *mtr;
997 vm_offset_t buf;
998 u_long latency;
999
1000 if (unit >= NMETEOR) {
1001 kprintf("meteor%d: attach: only %d units configured.\n",
1002 unit, NMETEOR);
1003 kprintf("meteor%d: attach: invalid unit number.\n", unit);
1004 return ;
1005 }
1006
1007 /*
1008 * Check for Meteor/PPB (PCI-PCI Bridge)
1009 * Reprogram IBM Bridge if detected.
1010 * New Meteor cards have an IBM PCI-PCI bridge, creating a secondary
1011 * PCI bus. The SAA chip is connected to this secondary bus.
1012 */
1013
1014 /* If we are not on PCI Bus 0, check for the Bridge */
1015 if ( pci_get_bus_from_tag( tag ) != 0) {
1016 pcici_t bridge_tag;
1017
1018 /* get tag of parent bridge */
1019 bridge_tag = pci_get_parent_from_tag( tag );
1020
1021 /* Look for IBM 82351, 82352 or 82353 */
1022 if (pci_conf_read(bridge_tag, PCI_ID_REG) == 0x00221014) {
1023
1024 if ( bootverbose)
1025 kprintf("meteor%d: PPB device detected, reprogramming IBM bridge.\n", unit);
1026
1027 /* disable SERR */
1028 pci_cfgwrite(bridge_tag, 0x05, 0x00, 1);
1029 /* set LATENCY */
1030 pci_cfgwrite(bridge_tag, 0x0d, 0x20, 1);
1031 /* write posting enable, prefetch enabled --> GRAB direction */
1032 pci_cfgwrite(bridge_tag, 0x42, 0x14, 1);
1033 /* set PRTR Primary retry timer register */
1034 pci_cfgwrite(bridge_tag, 0x4c, 0x10, 1);
1035 }
1036 }
1037
1038 mtr = &meteor[unit];
1039 mtr->tag = tag;
1040 pci_map_mem(tag, PCI_MAP_REG_START, (vm_offset_t *)&mtr->base,
1041 &mtr->phys_base);
1042
1043 #ifdef METEOR_IRQ /* from the configuration file */
1044 old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
1045 pci_conf_write(tag, PCI_INTERRUPT_REG, METEOR_IRQ);
1046 new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
1047 kprintf("meteor%d: attach: irq changed from %d to %d\n",
1048 unit, (old_irq & 0xff), (new_irq & 0xff));
1049 #endif /* METEOR_IRQ */
1050 /* setup the interrupt handling routine */
1051 pci_map_int(tag, meteor_intr, (void*) mtr);
1052
1053 /*
1054 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if
1055 * you have more than for, then 16 would probably be a better value.
1056 *
1057 */
1058 #ifndef METEOR_DEF_LATENCY_VALUE
1059 #define METEOR_DEF_LATENCY_VALUE 32
1060 #endif
1061 latency = pci_conf_read(tag, PCI_LATENCY_TIMER);
1062 latency = (latency >> 8) & 0xff;
1063 if(bootverbose) {
1064 if(latency)
1065 kprintf("meteor%d: PCI bus latency is", unit);
1066 else
1067 kprintf("meteor%d: PCI bus latency was 0 changing to",
1068 unit);
1069 }
1070 if(!latency) {
1071 latency = METEOR_DEF_LATENCY_VALUE;
1072 pci_conf_write(tag, PCI_LATENCY_TIMER, latency<<8);
1073 }
1074 if(bootverbose) {
1075 kprintf(" %lu.\n", latency);
1076 }
1077
1078 meteor_init(mtr); /* set up saa7116, saa7196, and rgb module */
1079
1080 if(METEOR_ALLOC)
1081 buf = get_meteor_mem(unit, METEOR_ALLOC);
1082 else
1083 buf = 0;
1084 if(bootverbose) {
1085 kprintf("meteor%d: buffer size %d, addr 0x%llx\n",
1086 unit, METEOR_ALLOC, vtophys(buf));
1087 }
1088
1089 mtr->bigbuf = buf;
1090 mtr->alloc_pages = METEOR_ALLOC_PAGES;
1091 if(buf != 0) {
1092 bzero((caddr_t) buf, METEOR_ALLOC);
1093 buf = vtophys(buf);
1094 /* 640x480 RGB 16 */
1095 mtr->base->dma1e = buf;
1096 mtr->base->dma1o = buf + 0x500;
1097 mtr->base->dma_end_e =
1098 mtr->base->dma_end_o = buf + METEOR_ALLOC;
1099 }
1100 /* 1 frame of 640x480 RGB 16 */
1101 mtr->cols = 640;
1102 mtr->rows = 480;
1103 mtr->depth = 2; /* two bytes per pixel */
1104 mtr->frames = 1; /* one frame */
1105
1106 mtr->flags |= METEOR_INITALIZED | METEOR_AUTOMODE | METEOR_DEV0 |
1107 METEOR_RGB16;
1108 dev_ops_add(&meteor_ops, -1, unit);
1109 make_dev(&meteor_ops, unit, 0, 0, 0644, "meteor");
1110 }
1111
1112 #define UNIT(x) ((x) & 0x07)
1113
1114 #ifdef unused
1115 static int
1116 meteor_reset(cdev_t dev)
1117 {
1118 int unit = UNIT(minor(dev));
1119 struct saa7116_regs *m;
1120
1121 if(unit >= NMETEOR)
1122 return ENXIO;
1123
1124 m = meteor[unit].base;
1125
1126 m->cap_cntl = 0x0;
1127 tsleep((caddr_t)m, METPRI, "Mreset", hz/50);
1128
1129 m->cap_cntl = 0x8ff0;
1130 m->cap_cntl = 0x80c0;
1131 m->cap_cntl = 0x8040;
1132 tsleep((caddr_t)m, METPRI, "Mreset", hz/10);
1133 m->cap_cntl = 0x80c0;
1134
1135 return 0;
1136
1137 }
1138 #endif
1139
1140 /*---------------------------------------------------------
1141 **
1142 ** Meteor character device driver routines
1143 **
1144 **---------------------------------------------------------
1145 */
1146
1147 int
1148 meteor_open(struct dev_open_args *ap)
1149 {
1150 cdev_t dev = ap->a_head.a_dev;
1151 meteor_reg_t *mtr;
1152 int unit;
1153 int i;
1154
1155 unit = UNIT(minor(dev));
1156 if (unit >= NMETEOR) /* unit out of range */
1157 return(ENXIO);
1158
1159 mtr = &(meteor[unit]);
1160
1161 if (!(mtr->flags & METEOR_INITALIZED)) /* device not found */
1162 return(ENXIO);
1163
1164 if (mtr->flags & METEOR_OPEN) /* device is busy */
1165 return(EBUSY);
1166
1167 mtr->flags |= METEOR_OPEN;
1168 /*
1169 * Make sure that the i2c regs are set the same for each open.
1170 */
1171 for(i=0; i< NUM_SAA7196_I2C_REGS; i++) {
1172 SAA7196_WRITE(mtr, i, saa7196_i2c_default[i]);
1173 }
1174
1175 mtr->fifo_errors = 0;
1176 mtr->dma_errors = 0;
1177 mtr->frames_captured = 0;
1178 mtr->even_fields_captured = 0;
1179 mtr->odd_fields_captured = 0;
1180 mtr->proc = (struct proc *)0;
1181 set_fps(mtr, 30);
1182 #ifdef METEOR_TEST_VIDEO
1183 mtr->video.addr = 0;
1184 mtr->video.width = 0;
1185 mtr->video.banksize = 0;
1186 mtr->video.ramsize = 0;
1187 #endif
1188
1189 return(0);
1190 }
1191
1192 int
1193 meteor_close(struct dev_close_args *ap)
1194 {
1195 cdev_t dev = ap->a_head.a_dev;
1196 meteor_reg_t *mtr;
1197 int unit;
1198 #ifdef METEOR_DEALLOC_ABOVE
1199 int temp;
1200 #endif
1201
1202 unit = UNIT(minor(dev));
1203 if (unit >= NMETEOR) /* unit out of range */
1204 return(ENXIO);
1205
1206 mtr = &(meteor[unit]);
1207 mtr->flags &= ~METEOR_OPEN;
1208
1209 if(mtr->flags & METEOR_SINGLE)
1210 /* this should not happen, the read capture
1211 should have completed or in the very least
1212 recieved a signal before close is called. */
1213 wakeup((caddr_t)mtr); /* continue read */
1214 /*
1215 * Turn off capture mode.
1216 */
1217 mtr->base->cap_cntl = 0x8ff0;
1218 mtr->flags &= ~(METEOR_CAP_MASK|METEOR_WANT_MASK);
1219 mtr->proc = (struct proc *)0;
1220
1221 #ifdef METEOR_DEALLOC_PAGES
1222 if (mtr->bigbuf != NULL) {
1223 kmem_free(&kernel_map, mtr->bigbuf,
1224 (mtr->alloc_pages * PAGE_SIZE));
1225 mtr->bigbuf = NULL;
1226 mtr->alloc_pages = 0;
1227 }
1228 #else
1229 #ifdef METEOR_DEALLOC_ABOVE
1230 if (mtr->bigbuf != NULL && mtr->alloc_pages > METEOR_DEALLOC_ABOVE) {
1231 temp = METEOR_DEALLOC_ABOVE - mtr->alloc_pages;
1232 kmem_free(&kernel_map,
1233 mtr->bigbuf+((mtr->alloc_pages - temp) * PAGE_SIZE),
1234 (temp * PAGE_SIZE));
1235 mtr->alloc_pages = METEOR_DEALLOC_ABOVE;
1236 }
1237 #endif
1238 #endif
1239
1240 return(0);
1241 }
1242
1243 static void
1244 start_capture(meteor_reg_t *mtr, unsigned type)
1245 {
1246 mreg_t *cap = &mtr->base->cap_cntl;
1247
1248 mtr->flags |= type;
1249 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
1250 case METEOR_ONLY_EVEN_FIELDS:
1251 mtr->flags |= METEOR_WANT_EVEN;
1252 if(type == METEOR_SINGLE)
1253 *cap = 0x0ff4 | mtr->range_enable;
1254 else
1255 *cap = 0x0ff1 | mtr->range_enable;
1256 break;
1257 case METEOR_ONLY_ODD_FIELDS:
1258 mtr->flags |= METEOR_WANT_ODD;
1259 if(type == METEOR_SINGLE)
1260 *cap = 0x0ff8 | mtr->range_enable;
1261 else
1262 *cap = 0x0ff2 | mtr->range_enable;
1263 break;
1264 default:
1265 mtr->flags |= METEOR_WANT_MASK;
1266 if(type == METEOR_SINGLE)
1267 *cap = 0x0ffc | mtr->range_enable;
1268 else
1269 *cap = 0x0ff3 | mtr->range_enable;
1270 break;
1271 }
1272 }
1273
1274 int
1275 meteor_read(struct dev_read_args *ap)
1276 {
1277 cdev_t dev = ap->a_head.a_dev;
1278 struct uio *uio = ap->a_uio;
1279 meteor_reg_t *mtr;
1280 int unit;
1281 int status;
1282 int count;
1283
1284 unit = UNIT(minor(dev));
1285 if (unit >= NMETEOR) /* unit out of range */
1286 return(ENXIO);
1287
1288 mtr = &(meteor[unit]);
1289 if (mtr->bigbuf == 0)/* no frame buffer allocated (ioctl failed) */
1290 return(ENOMEM);
1291
1292 if (mtr->flags & METEOR_CAP_MASK)
1293 return(EIO); /* already capturing */
1294
1295 count = mtr->rows * mtr->cols * mtr->depth;
1296 if (uio->uio_iov->iov_len < count)
1297 return(EINVAL);
1298
1299 /* Start capture */
1300 start_capture(mtr, METEOR_SINGLE);
1301
1302 status=tsleep((caddr_t)mtr, METPRI, "capturing", 0);
1303 if (!status) /* successful capture */
1304 status = uiomove((caddr_t)mtr->bigbuf, count, uio);
1305 else
1306 kprintf ("meteor%d: read: tsleep error %d\n", unit, status);
1307
1308 mtr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK);
1309
1310 return(status);
1311 }
1312
1313 int
1314 meteor_write(struct dev_write_args *ap)
1315 {
1316 return(0);
1317 }
1318
1319 int
1320 meteor_ioctl(struct dev_ioctl_args *ap)
1321 {
1322 cdev_t dev = ap->a_head.a_dev;
1323 caddr_t data = ap->a_data;
1324 int error;
1325 int unit;
1326 unsigned int temp;
1327 meteor_reg_t *mtr;
1328 struct meteor_counts *cnt;
1329 struct meteor_geomet *geo;
1330 struct meteor_mem *mem;
1331 struct meteor_capframe *frame;
1332 #ifdef METEOR_TEST_VIDEO
1333 struct meteor_video *video;
1334 #endif
1335 vm_offset_t buf;
1336 struct saa7116_regs *base;
1337
1338 error = 0;
1339
1340 if (data == NULL)
1341 return(EINVAL);
1342 unit = UNIT(minor(dev));
1343 if (unit >= NMETEOR) /* unit out of range */
1344 return(ENXIO);
1345
1346 mtr = &(meteor[unit]);
1347 base = mtr->base;
1348
1349 switch (ap->a_cmd) {
1350 case METEORSTS:
1351 if(*data)
1352 mtr->flags |= METEOR_WANT_TS;
1353 else
1354 mtr->flags &= ~METEOR_WANT_TS;
1355 break;
1356 case METEORGTS:
1357 if(mtr->flags & METEOR_WANT_TS)
1358 *data = 1;
1359 else
1360 *data = 0;
1361 break;
1362 #ifdef METEOR_TEST_VIDEO
1363 case METEORGVIDEO:
1364 video = (struct meteor_video *)data;
1365 video->addr = mtr->video.addr;
1366 video->width = mtr->video.width;
1367 video->banksize = mtr->video.banksize;
1368 video->ramsize = mtr->video.ramsize;
1369 break;
1370 case METEORSVIDEO:
1371 video = (struct meteor_video *)data;
1372 mtr->video.addr = video->addr;
1373 mtr->video.width = video->width;
1374 mtr->video.banksize = video->banksize;
1375 mtr->video.ramsize = video->ramsize;
1376 break;
1377 #endif
1378 case METEORSFPS:
1379 set_fps(mtr, *(u_short *)data);
1380 break;
1381 case METEORGFPS:
1382 *(u_short *)data = mtr->fps;
1383 break;
1384 case METEORSSIGNAL:
1385 if (*(int *)data < 0 || *(int *)data > _SIG_MAXSIG)
1386 return EINVAL;
1387 mtr->signal = *(int *) data;
1388 if (mtr->signal) {
1389 mtr->proc = curproc; /* might be NULL */
1390 } else {
1391 mtr->proc = (struct proc *)0;
1392 }
1393 break;
1394 case METEORGSIGNAL:
1395 *(int *)data = mtr->signal;
1396 break;
1397 case METEORSTATUS: /* get 7196 status */
1398 temp = 0;
1399 SAA7196_WRITE(mtr, SAA7196_STDC,
1400 SAA7196_REG(mtr, SAA7196_STDC) | 0x02);
1401 SAA7196_READ(mtr);
1402 temp |= (base->i2c_read & 0xff000000L) >> 24;
1403 SAA7196_WRITE(mtr, SAA7196_STDC,
1404 SAA7196_REG(mtr, SAA7196_STDC) & ~0x02);
1405 SAA7196_READ(mtr);
1406 temp |= (base->i2c_read & 0xff000000L) >> 16;
1407 *(u_short *)data = temp;
1408 break;
1409 case METEORSHUE: /* set hue */
1410 SAA7196_WRITE(mtr, SAA7196_HUEC, *(char *)data);
1411 break;
1412 case METEORGHUE: /* get hue */
1413 *(char *)data = SAA7196_REG(mtr, SAA7196_HUEC);
1414 break;
1415 case METEORSCHCV: /* set chrominance gain */
1416 SAA7196_WRITE(mtr, SAA7196_CGAINR, *(char *)data);
1417 break;
1418 case METEORGCHCV: /* get chrominance gain */
1419 *(char *)data = SAA7196_REG(mtr, SAA7196_CGAINR);
1420 break;
1421 case METEORSBRIG: /* set brightness */
1422 SAA7196_WRITE(mtr, SAA7196_BRIG, *(char *)data);
1423 break;
1424 case METEORGBRIG: /* get brightness */
1425 *(char *)data = SAA7196_REG(mtr, SAA7196_BRIG);
1426 break;
1427 case METEORSCSAT: /* set chroma saturation */
1428 SAA7196_WRITE(mtr, SAA7196_CSAT, *(char *)data);
1429 break;
1430 case METEORGCSAT: /* get chroma saturation */
1431 *(char *)data = SAA7196_REG(mtr, SAA7196_CSAT);
1432 break;
1433 case METEORSCONT: /* set contrast */
1434 SAA7196_WRITE(mtr, SAA7196_CONT, *(char *)data);
1435 break;
1436 case METEORGCONT: /* get contrast */
1437 *(char *)data = SAA7196_REG(mtr, SAA7196_CONT);
1438 break;
1439 case METEORSBT254:
1440 if((mtr->flags & METEOR_RGB) == 0)
1441 return EINVAL;
1442 temp = *(unsigned short *)data;
1443 bt254_write(mtr, temp & 0xf, (temp & 0x0ff0) >> 4);
1444 break;
1445 case METEORGBT254:
1446 if((mtr->flags & METEOR_RGB) == 0)
1447 return EINVAL;
1448 temp = *(unsigned short *)data & 0x7;
1449 *(unsigned short *)data = mtr->bt254_reg[temp] << 4 | temp;
1450 break;
1451 case METEORSHWS: /* set horizontal window start */
1452 SAA7196_WRITE(mtr, SAA7196_HWS, *(char *)data);
1453 break;
1454 case METEORGHWS: /* get horizontal window start */
1455 *(char *)data = SAA7196_REG(mtr, SAA7196_HWS);
1456 break;
1457 case METEORSVWS: /* set vertical window start */
1458 SAA7196_WRITE(mtr, SAA7196_VWS, *(char *)data);
1459 break;
1460 case METEORGVWS: /* get vertical window start */
1461 *(char *)data = SAA7196_REG(mtr, SAA7196_VWS);
1462 break;
1463 case METEORSINPUT: /* set input device */
1464 switch(*(unsigned long *)data & METEOR_DEV_MASK) {
1465 case 0: /* default */
1466 case METEOR_INPUT_DEV0:
1467 if(mtr->flags & METEOR_RGB)
1468 select_saa7196(mtr);
1469 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1470 | METEOR_DEV0;
1471 SAA7196_WRITE(mtr, 0x0e,
1472 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x0);
1473 SAA7196_WRITE(mtr, 0x06,
1474 (SAA7196_REG(mtr, 0x06) & ~0x80));
1475 break;
1476 case METEOR_INPUT_DEV1:
1477 if(mtr->flags & METEOR_RGB)
1478 select_saa7196(mtr);
1479 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1480 | METEOR_DEV1;
1481 SAA7196_WRITE(mtr, 0x0e,
1482 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x1);
1483 SAA7196_WRITE(mtr, 0x06,
1484 (SAA7196_REG(mtr, 0x06) & ~0x80));
1485 break;
1486 case METEOR_INPUT_DEV2:
1487 if(mtr->flags & METEOR_RGB)
1488 select_saa7196(mtr);
1489 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1490 | METEOR_DEV2;
1491 SAA7196_WRITE(mtr, 0x0e,
1492 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x2);
1493 SAA7196_WRITE(mtr, 0x06,
1494 (SAA7196_REG(mtr, 0x06) & ~0x80));
1495 break;
1496 case METEOR_INPUT_DEV3:
1497 if(mtr->flags & METEOR_RGB)
1498 select_saa7196(mtr);
1499 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1500 | METEOR_DEV3;
1501 SAA7196_WRITE(mtr, 0x0e,
1502 (SAA7196_REG(mtr, 0x0e) | 0x3));
1503 SAA7196_WRITE(mtr, 0x06,
1504 (SAA7196_REG(mtr, 0x06) & ~0x80) );
1505 break;
1506 case METEOR_INPUT_DEV_SVIDEO:
1507 if(mtr->flags & METEOR_RGB)
1508 select_saa7196(mtr);
1509 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1510 | METEOR_DEV_SVIDEO;
1511 SAA7196_WRITE(mtr, 0x0e,
1512 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x2);
1513 SAA7196_WRITE(mtr, 0x06,
1514 (SAA7196_REG(mtr, 0x06) & ~0x80) | 0x80);
1515 break;
1516 case METEOR_INPUT_DEV_RGB:
1517 if((mtr->flags & METEOR_RGB) == 0)
1518 return EINVAL;
1519 mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
1520 | METEOR_DEV_RGB;
1521 SAA7196_WRITE(mtr, 0x0e,
1522 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x3);
1523 SAA7196_WRITE(mtr, 0x06,
1524 (SAA7196_REG(mtr, 0x06) & ~0x80));
1525 select_bt254(mtr);
1526 SAA7196_WRITE(mtr, 0x0e, /* chn 3 for synch */
1527 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x3);
1528 break;
1529 default:
1530 return EINVAL;
1531 }
1532 break;
1533 case METEORGINPUT: /* get input device */
1534 *(u_long *)data = mtr->flags & METEOR_DEV_MASK;
1535 break;
1536 case METEORSFMT: /* set input format */
1537 switch(*(unsigned long *)data & METEOR_FORM_MASK ) {
1538 case 0: /* default */
1539 case METEOR_FMT_NTSC:
1540 mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
1541 METEOR_NTSC;
1542 SAA7196_WRITE(mtr, SAA7196_STDC,
1543 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
1544 SAA7196_WRITE(mtr, 0x0f,
1545 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x40);
1546 SAA7196_WRITE(mtr, 0x22, 0x80);
1547 SAA7196_WRITE(mtr, 0x24,
1548 (SAA7196_REG(mtr, 0x24) & ~0x0c) | 0x08);
1549 SAA7196_WRITE(mtr, 0x26, 0xf0);
1550 SAA7196_WRITE(mtr, 0x28,
1551 (SAA7196_REG(mtr, 0x28) & ~0x0c)) ;
1552 if(mtr->flags & METEOR_RGB){
1553 bt254_ntsc(mtr, 1);
1554 }
1555 break;
1556 case METEOR_FMT_PAL:
1557 mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
1558 METEOR_PAL;
1559 SAA7196_WRITE(mtr, SAA7196_STDC,
1560 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
1561 SAA7196_WRITE(mtr, 0x0f,
1562 (SAA7196_REG(mtr, 0x0f) & ~0xe0));
1563 SAA7196_WRITE(mtr, 0x22, 0x00);
1564 SAA7196_WRITE(mtr, 0x24,
1565 (SAA7196_REG(mtr, 0x24) | 0x0c));
1566 SAA7196_WRITE(mtr, 0x26, 0x20);
1567 SAA7196_WRITE(mtr, 0x28,
1568 (SAA7196_REG(mtr, 0x28) & ~0x0c) | 0x04) ;
1569 if(mtr->flags & METEOR_RGB){
1570 bt254_ntsc(mtr, 0);
1571 }
1572 break;
1573 case METEOR_FMT_SECAM:
1574 mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
1575 METEOR_SECAM;
1576 SAA7196_WRITE(mtr, SAA7196_STDC,
1577 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01) | 0x1);
1578 SAA7196_WRITE(mtr, 0x0f,
1579 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x20);
1580 SAA7196_WRITE(mtr, 0x22, 0x00);
1581 SAA7196_WRITE(mtr, 0x24,
1582 (SAA7196_REG(mtr, 0x24) | 0x0c));
1583 SAA7196_WRITE(mtr, 0x26, 0x20);
1584 SAA7196_WRITE(mtr, 0x28,
1585 (SAA7196_REG(mtr, 0x28) & ~0x0c) | 0x04) ;
1586 if(mtr->flags & METEOR_RGB){
1587 bt254_ntsc(mtr, 0);
1588 }
1589 break;
1590 case METEOR_FMT_AUTOMODE:
1591 mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
1592 METEOR_AUTOMODE;
1593 SAA7196_WRITE(mtr, SAA7196_STDC,
1594 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
1595 SAA7196_WRITE(mtr, 0x0f,
1596 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x80);
1597 break;
1598 default:
1599 return EINVAL;
1600 }
1601 break;
1602 case METEORGFMT: /* get input format */
1603 *(u_long *)data = mtr->flags & METEOR_FORM_MASK;
1604 break;
1605 case METEORCAPTUR:
1606 temp = mtr->flags;
1607 switch (*(int *) data) {
1608 case METEOR_CAP_SINGLE:
1609 if (mtr->bigbuf==0) /* no frame buffer allocated */
1610 return(ENOMEM);
1611
1612 if (temp & METEOR_CAP_MASK)
1613 return(EIO); /* already capturing */
1614
1615 start_capture(mtr, METEOR_SINGLE);
1616
1617 /* wait for capture to complete */
1618 error=tsleep((caddr_t)mtr, METPRI, "capturing", 0);
1619 if(error)
1620 kprintf("meteor%d: ioctl: tsleep error %d\n",
1621 unit, error);
1622 mtr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
1623 break;
1624 case METEOR_CAP_CONTINOUS:
1625 if (mtr->bigbuf==0) /* no frame buffer allocated */
1626 return(ENOMEM);
1627
1628 if (temp & METEOR_CAP_MASK)
1629 return(EIO); /* already capturing */
1630
1631 start_capture(mtr, METEOR_CONTIN);
1632
1633 break;
1634 case METEOR_CAP_STOP_CONT:
1635 if (mtr->flags & METEOR_CONTIN) {
1636 /* turn off capture */
1637 base->cap_cntl = 0x8ff0;
1638 mtr->flags &= ~(METEOR_CONTIN|METEOR_WANT_MASK);
1639 }
1640 break;
1641
1642 default:
1643 error = EINVAL;
1644 break;
1645 }
1646 break;
1647 case METEORCAPFRM:
1648 frame = (struct meteor_capframe *) data;
1649 if (!frame)
1650 return(EINVAL);
1651 switch (frame->command) {
1652 case METEOR_CAP_N_FRAMES:
1653 if (mtr->flags & METEOR_CAP_MASK)
1654 return(EIO);
1655 if (mtr->flags & (METEOR_YUV_PLANAR | METEOR_YUV_422)) /* XXX */
1656 return(EINVAL); /* should fix intr so we allow these */
1657 if (mtr->bigbuf == 0)
1658 return(ENOMEM);
1659 if ((mtr->frames < 2) ||
1660 (frame->lowat < 1 || frame->lowat >= mtr->frames) ||
1661 (frame->hiwat < 1 || frame->hiwat >= mtr->frames) ||
1662 (frame->lowat > frame->hiwat))
1663 return(EINVAL);
1664 /* meteor_mem structure is on the page after the data */
1665 mem = mtr->mem = (struct meteor_mem *) (mtr->bigbuf +
1666 (round_page(mtr->frame_size * mtr->frames)));
1667 mtr->current = 1;
1668 mtr->synch_wait = 0;
1669 mem->num_bufs = mtr->frames;
1670 mem->frame_size= mtr->frame_size;
1671 /* user and kernel change these */
1672 mem->lowat = frame->lowat;
1673 mem->hiwat = frame->hiwat;
1674 mem->active = 0;
1675 mem->num_active_bufs = 0;
1676 /* Start capture */
1677 start_capture(mtr, METEOR_SYNCAP);
1678 break;
1679 case METEOR_CAP_STOP_FRAMES:
1680 if (mtr->flags & METEOR_SYNCAP) {
1681 /* turn off capture */
1682 base->cap_cntl = 0x8ff0;
1683 mtr->flags &= ~(METEOR_SYNCAP|METEOR_WANT_MASK);
1684 }
1685 break;
1686 case METEOR_HALT_N_FRAMES:
1687 if(mtr->flags & METEOR_SYNCAP) {
1688 base->cap_cntl = 0x8ff0;
1689 mtr->flags &= ~(METEOR_WANT_MASK);
1690 }
1691 break;
1692 case METEOR_CONT_N_FRAMES:
1693 if(!(mtr->flags & METEOR_SYNCAP)) {
1694 error = EINVAL;
1695 break;
1696 }
1697 start_capture(mtr, METEOR_SYNCAP);
1698 break;
1699 default:
1700 error = EINVAL;
1701 break;
1702 }
1703 break;
1704
1705 case METEORSETGEO:
1706 geo = (struct meteor_geomet *) data;
1707
1708 /* Either even or odd, if even & odd, then these a zero */
1709 if((geo->oformat & METEOR_GEO_ODD_ONLY) &&
1710 (geo->oformat & METEOR_GEO_EVEN_ONLY)) {
1711 kprintf("meteor%d: ioctl: Geometry odd or even only.\n",
1712 unit);
1713 return EINVAL;
1714 }
1715 /* set/clear even/odd flags */
1716 if(geo->oformat & METEOR_GEO_ODD_ONLY)
1717 mtr->flags |= METEOR_ONLY_ODD_FIELDS;
1718 else
1719 mtr->flags &= ~METEOR_ONLY_ODD_FIELDS;
1720 if(geo->oformat & METEOR_GEO_EVEN_ONLY)
1721 mtr->flags |= METEOR_ONLY_EVEN_FIELDS;
1722 else
1723 mtr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
1724
1725 /* can't change parameters while capturing */
1726 if (mtr->flags & METEOR_CAP_MASK)
1727 return(EBUSY);
1728
1729 if ((geo->columns & 0x3fe) != geo->columns) {
1730 kprintf(
1731 "meteor%d: ioctl: %d: columns too large or not even.\n",
1732 unit, geo->columns);
1733 error = EINVAL;
1734 }
1735 if (((geo->rows & 0x7fe) != geo->rows) ||
1736 ((geo->oformat & METEOR_GEO_FIELD_MASK) &&
1737 ((geo->rows & 0x3fe) != geo->rows)) ) {
1738 kprintf(
1739 "meteor%d: ioctl: %d: rows too large or not even.\n",
1740 unit, geo->rows);
1741 error = EINVAL;
1742 }
1743 if (geo->frames > 32) {
1744 kprintf("meteor%d: ioctl: too many frames.\n", unit);
1745 error = EINVAL;
1746 }
1747 if(error) return error;
1748
1749 if ((temp=geo->rows * geo->columns * geo->frames * 2) != 0) {
1750 if (geo->oformat & METEOR_GEO_RGB24) temp = temp * 2;
1751
1752 /* meteor_mem structure for SYNC Capture */
1753 if (geo->frames > 1) temp += PAGE_SIZE;
1754
1755 temp = btoc(temp);
1756 if (temp > mtr->alloc_pages
1757 #ifdef METEOR_TEST_VIDEO
1758 && mtr->video.addr == 0
1759 #endif
1760 ) {
1761 buf = get_meteor_mem(unit, temp*PAGE_SIZE);
1762 if(buf != 0) {
1763 kmem_free(&kernel_map, mtr->bigbuf,
1764 (mtr->alloc_pages * PAGE_SIZE));
1765 mtr->bigbuf = buf;
1766 mtr->alloc_pages = temp;
1767 if(bootverbose)
1768 kprintf(
1769 "meteor%d: ioctl: Allocating %d bytes\n",
1770 unit, temp*PAGE_SIZE);
1771 } else {
1772 error = ENOMEM;
1773 }
1774 }
1775 }
1776 if(error) return error;
1777
1778 mtr->rows = geo->rows;
1779 mtr->cols = geo->columns;
1780 mtr->frames = geo->frames;
1781
1782 #ifdef METEOR_TEST_VIDEO
1783 if(mtr->video.addr)
1784 buf = vtophys(mtr->video.addr);
1785 else
1786 #endif
1787 buf = vtophys(mtr->bigbuf);
1788
1789 /* set defaults and end of buffer locations */
1790 base->dma1e = buf;
1791 base->dma2e = buf;
1792 base->dma3e = buf;
1793 base->dma1o = buf;
1794 base->dma2o = buf;
1795 base->dma3o = buf;
1796 base->stride1e = 0;
1797 base->stride2e = 0;
1798 base->stride3e = 0;
1799 base->stride1o = 0;
1800 base->stride2o = 0;
1801 base->stride3o = 0;
1802 /* set end of DMA location, even/odd */
1803 base->dma_end_e =
1804 base->dma_end_o = buf + mtr->alloc_pages * PAGE_SIZE;
1805
1806 /*
1807 * Determine if we can use the hardware range detect.
1808 */
1809 if(mtr->alloc_pages * PAGE_SIZE < RANGE_BOUNDARY &&
1810 ((buf & 0xff000000) | base->dma_end_e) ==
1811 (buf + mtr->alloc_pages * PAGE_SIZE) )
1812 mtr->range_enable = 0x8000;
1813 else {
1814 mtr->range_enable = 0x0;
1815 base->dma_end_e =
1816 base->dma_end_o = 0xffffffff;
1817 }
1818
1819
1820 switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) {
1821 case 0: /* default */
1822 case METEOR_GEO_RGB16:
1823 mtr->depth = 2;
1824 mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
1825 mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
1826 mtr->flags |= METEOR_RGB16;
1827 temp = mtr->cols * mtr->depth;
1828 /* recal stride and starting point */
1829 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
1830 case METEOR_ONLY_ODD_FIELDS:
1831 base->dma1o = buf;
1832 #ifdef METEOR_TEST_VIDEO
1833 if(mtr->video.addr && mtr->video.width)
1834 base->stride1o = mtr->video.width-temp;
1835 #endif
1836 SAA7196_WRITE(mtr, 0x20, 0xd0);
1837 break;
1838 case METEOR_ONLY_EVEN_FIELDS:
1839 base->dma1e = buf;
1840 #ifdef METEOR_TEST_VIDEO
1841 if(mtr->video.addr && mtr->video.width)
1842 base->stride1e = mtr->video.width-temp;
1843 #endif
1844 SAA7196_WRITE(mtr, 0x20, 0xf0);
1845 break;
1846 default: /* interlaced even/odd */
1847 base->dma1e = buf;
1848 base->dma1o = buf + temp;
1849 base->stride1e = base->stride1o = temp;
1850 #ifdef METEOR_TEST_VIDEO
1851 if(mtr->video.addr && mtr->video.width) {
1852 base->dma1o = buf + mtr->video.width;
1853 base->stride1e = base->stride1o =
1854 mtr->video.width -
1855 temp + mtr->video.width;
1856 }
1857 #endif
1858 SAA7196_WRITE(mtr, 0x20, 0x90);
1859 break;
1860 }
1861 base->routee = base->routeo = 0xeeeeee01;
1862 break;
1863 case METEOR_GEO_RGB24:
1864 mtr->depth = 4;
1865 mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
1866 mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
1867 mtr->flags |= METEOR_RGB24;
1868 temp = mtr->cols * mtr->depth;
1869 /* recal stride and starting point */
1870 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
1871 case METEOR_ONLY_ODD_FIELDS:
1872 base->dma1o = buf;
1873 #ifdef METEOR_TEST_VIDEO
1874 if(mtr->video.addr && mtr->video.width)
1875 base->stride1o = mtr->video.width-temp;
1876 #endif
1877 SAA7196_WRITE(mtr, 0x20, 0xd2);
1878 break;
1879 case METEOR_ONLY_EVEN_FIELDS:
1880 base->dma1e = buf;
1881 #ifdef METEOR_TEST_VIDEO
1882 if(mtr->video.addr && mtr->video.width)
1883 base->stride1e = mtr->video.width-temp;
1884 #endif
1885 SAA7196_WRITE(mtr, 0x20, 0xf2);
1886 break;
1887 default: /* interlaced even/odd */
1888 base->dma1e = buf;
1889 base->dma1o = buf + mtr->cols * mtr->depth;
1890 base->stride1e = base->stride1o =
1891 mtr->cols * mtr->depth;
1892 #ifdef METEOR_TEST_VIDEO
1893 if(mtr->video.addr && mtr->video.width) {
1894 base->dma1o = buf + mtr->video.width;
1895 base->stride1e = base->stride1o =
1896 mtr->video.width -
1897 temp + mtr->video.width;
1898 }
1899 #endif
1900 SAA7196_WRITE(mtr, 0x20, 0x92);
1901 break;
1902 }
1903 base->routee= base->routeo= 0x39393900;
1904 break;
1905 case METEOR_GEO_YUV_PLANAR:
1906 mtr->depth = 2;
1907 temp = mtr->rows * mtr->cols; /* compute frame size */
1908 mtr->frame_size = temp * mtr->depth;
1909 mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
1910 mtr->flags |= METEOR_YUV_PLANAR;
1911 /* recal stride and starting point */
1912 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
1913 case METEOR_ONLY_ODD_FIELDS:
1914 base->dma1o = buf; /* Y Odd */
1915 base->dma2o = buf + temp; /* U Odd */
1916 temp >>= 1;
1917 base->dma3o = base->dma2o + temp; /* V Odd */
1918 SAA7196_WRITE(mtr, 0x20, 0xd1);
1919 break;
1920 case METEOR_ONLY_EVEN_FIELDS:
1921 base->dma1e = buf; /* Y Even */
1922 base->dma2e = buf + temp; /* U Even */
1923 temp >>= 1;
1924 base->dma2e= base->dma2e + temp; /* V Even */
1925 SAA7196_WRITE(mtr, 0x20, 0xf1);
1926 break;
1927 default: /* interlaced even/odd */
1928 base->dma1e = buf; /* Y Even */
1929 base->dma2e = buf + temp; /* U Even */
1930 temp >>= 2;
1931 base->dma3e = base->dma2e + temp; /* V Even */
1932 base->dma1o = base->dma1e+mtr->cols;/* Y Odd */
1933 base->dma2o = base->dma3e + temp; /* U Odd */
1934 base->dma3o = base->dma2o + temp; /* V Odd */
1935 base->stride1e = base->stride1o = mtr->cols;
1936 SAA7196_WRITE(mtr, 0x20, 0x91);
1937 break;
1938 }
1939 switch (geo->oformat &
1940 (METEOR_GEO_YUV_12 | METEOR_GEO_YUV_9)) {
1941 case METEOR_GEO_YUV_9:
1942 base->routee=base->routeo = 0xaaaaffc3;
1943 break;
1944 case METEOR_GEO_YUV_12:
1945 base->routee=base->routeo = 0xaaaaffc2;
1946 break;
1947 default:
1948 base->routee=base->routeo = 0xaaaaffc1;
1949 break;
1950 }
1951 break;
1952 case METEOR_GEO_YUV_422:/* same as planer, different uv order */
1953 mtr->depth = 2;
1954 temp = mtr->rows * mtr->cols; /* compute frame size */
1955 mtr->frame_size = temp * mtr->depth;
1956 mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
1957 mtr->flags |= METEOR_YUV_422;
1958 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
1959 case METEOR_ONLY_ODD_FIELDS:
1960 base->dma1o = buf;
1961 base->dma2o = buf + temp;
1962 base->dma3o = base->dma2o + (temp >> 1);
1963 SAA7196_WRITE(mtr, 0x20, 0xd1);
1964 break;
1965 case METEOR_ONLY_EVEN_FIELDS:
1966 base->dma1e = buf;
1967 base->dma2e = buf + temp;
1968 base->dma3e = base->dma2e + (temp >> 1);
1969 SAA7196_WRITE(mtr, 0x20, 0xf1);
1970 break;
1971 default: /* interlaced even/odd */
1972 base->dma1e = buf; /* Y even */
1973 base->dma2e = buf + temp; /* U even */
1974 base->dma3e =
1975 base->dma2e + (temp >> 1);/* V even */
1976 base->dma1o = base->dma1e+mtr->cols;/* Y odd */
1977 temp = mtr->cols >> 1;
1978 base->dma2o = base->dma2e+temp; /* U odd */
1979 base->dma3o = base->dma3e+temp; /* V odd */
1980 base->stride1e =
1981 base->stride1o = mtr->cols; /* Y stride */
1982 base->stride2e =
1983 base->stride2o = temp; /* U stride */
1984 base->stride3e =
1985 base->stride3o = temp; /* V stride */
1986 SAA7196_WRITE(mtr, 0x20, 0x91);
1987 break;
1988 }
1989 switch (geo->oformat &
1990 (METEOR_GEO_YUV_12 | METEOR_GEO_YUV_9)) {
1991 case METEOR_GEO_YUV_9:
1992 base->routee=base->routeo = 0xaaaaffc3;
1993 break;
1994 case METEOR_GEO_YUV_12:
1995 base->routee=base->routeo = 0xaaaaffc2;
1996 break;
1997 default:
1998 base->routee=base->routeo = 0xaaaaffc1;
1999 break;
2000 }
2001 break;
2002 case METEOR_GEO_YUV_PACKED:
2003 mtr->depth = 2;
2004 mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
2005 mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
2006 mtr->flags |= METEOR_YUV_PACKED;
2007 /* recal stride and odd starting point */
2008 switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
2009 case METEOR_ONLY_ODD_FIELDS:
2010 base->dma1o = buf;
2011 SAA7196_WRITE(mtr, 0x20, 0xd1);
2012 break;
2013 case METEOR_ONLY_EVEN_FIELDS:
2014 base->dma1e = buf;
2015 SAA7196_WRITE(mtr, 0x20, 0xf1);
2016 break;
2017 default: /* interlaced even/odd */
2018 base->dma1e = buf;
2019 base->dma1o = buf + mtr->cols * mtr->depth;
2020 base->stride1e = base->stride1o =
2021 mtr->cols * mtr->depth;
2022 SAA7196_WRITE(mtr, 0x20, 0x91);
2023 break;
2024 }
2025 base->routee = base->routeo = 0xeeeeee41;
2026 break;
2027 default:
2028 error = EINVAL; /* invalid argument */
2029 kprintf("meteor%d: ioctl: invalid output format\n",unit);
2030 break;
2031 }
2032 /* set cols */
2033 SAA7196_WRITE(mtr, 0x21, mtr->cols & 0xff);
2034 SAA7196_WRITE(mtr, 0x24,
2035 ((SAA7196_REG(mtr, 0x24) & ~0x03) |
2036 ((mtr->cols >> 8) & 0x03)));
2037 /* set rows */
2038 if(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
2039 SAA7196_WRITE(mtr, 0x25, ((mtr->rows) & 0xff));
2040 SAA7196_WRITE(mtr, 0x28,
2041 ((SAA7196_REG(mtr, 0x28) & ~0x03) |
2042 ((mtr->rows >> 8) & 0x03)));
2043 } else { /* Interlaced */
2044 SAA7196_WRITE(mtr, 0x25, ((mtr->rows >> 1) & 0xff));
2045 SAA7196_WRITE(mtr, 0x28,
2046 ((SAA7196_REG(mtr, 0x28) & ~0x03) |
2047 ((mtr->rows >> 9) & 0x03)));
2048 }
2049 /* set signed/unsigned chrominance */
2050 SAA7196_WRITE(mtr, 0x30, (SAA7196_REG(mtr, 0x30) & ~0x10) |
2051 ((geo->oformat&METEOR_GEO_UNSIGNED)?0:0x10));
2052 break;
2053 case METEORGETGEO:
2054 geo = (struct meteor_geomet *) data;
2055 geo->rows = mtr->rows;
2056 geo->columns = mtr->cols;
2057 geo->frames = mtr->frames;
2058 geo->oformat = (mtr->flags & METEOR_OUTPUT_FMT_MASK) |
2059 (mtr->flags & METEOR_ONLY_FIELDS_MASK) |
2060 (SAA7196_REG(mtr, 0x30) & 0x10 ?
2061 0:METEOR_GEO_UNSIGNED);
2062 switch(base->routee & 0xff) {
2063 case 0xc3:
2064 geo->oformat |= METEOR_GEO_YUV_9;
2065 break;
2066 case 0xc2:
2067 geo->oformat |= METEOR_GEO_YUV_12;
2068 break;
2069 default:
2070 break;
2071 }
2072 break;
2073 case METEORSCOUNT: /* (re)set error counts */
2074 cnt = (struct meteor_counts *) data;
2075 mtr->fifo_errors = cnt->fifo_errors;
2076 mtr->dma_errors = cnt->dma_errors;
2077 mtr->frames_captured = cnt->frames_captured;
2078 mtr->even_fields_captured = cnt->even_fields_captured;
2079 mtr->odd_fields_captured = cnt->odd_fields_captured;
2080 break;
2081 case METEORGCOUNT: /* get error counts */
2082 cnt = (struct meteor_counts *) data;
2083 cnt->fifo_errors = mtr->fifo_errors;
2084 cnt->dma_errors = mtr->dma_errors;
2085 cnt->frames_captured = mtr->frames_captured;
2086 cnt->even_fields_captured = mtr->even_fields_captured;
2087 cnt->odd_fields_captured = mtr->odd_fields_captured;
2088 break;
2089 default:
2090 kprintf("meteor%d: ioctl: invalid ioctl request\n", unit);
2091 error = ENOTTY;
2092 break;
2093 }
2094 return(error);
2095 }
2096
2097 int
2098 meteor_mmap(struct dev_mmap_args *ap)
2099 {
2100 cdev_t dev = ap->a_head.a_dev;
2101 int unit;
2102 meteor_reg_t *mtr;
2103
2104 unit = UNIT(minor(dev));
2105 if (unit >= NMETEOR) /* at this point could this happen? */
2106 return(-1);
2107
2108 mtr = &(meteor[unit]);
2109
2110
2111 if (ap->a_nprot & PROT_EXEC)
2112 return -1;
2113
2114 if (ap->a_offset >= mtr->alloc_pages * PAGE_SIZE)
2115 return -1;
2116
2117 return i386_btop(vtophys(mtr->bigbuf) + ap->a_offset);
2118 }
DragonFly BSD