summaryrefslogtreecommitdiff
path: root/src/sna/sna.h
blob: 3c5d56b331d9fbd8324215c9465df4fc0b34632d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
/**************************************************************************

Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright © 2002 David Dawes

All Rights Reserved.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sub license, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice (including the
next paragraph) shall be included in all copies or substantial portions
of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

**************************************************************************/

/*
 * Authors:
 *   Keith Whitwell <keith@tungstengraphics.com>
 *   David Dawes <dawes@xfree86.org>
 *
 */

#ifndef _SNA_H_
#define _SNA_H_

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdint.h>

#include "compiler.h"
#include <xf86_OSproc.h>
#include <xf86PciInfo.h>
#include <xf86Pci.h>
#include <xf86Cursor.h>
#include <xf86xv.h>
#include <xf86Crtc.h>
#include <xf86RandR12.h>
#include <gcstruct.h>

#include <xorg-server.h>
#include <pciaccess.h>

#include <xf86drm.h>
#include <xf86drmMode.h>

#define _XF86DRI_SERVER_
#include <dri2.h>
#include <i915_drm.h>

#if HAVE_UDEV
#include <libudev.h>
#endif

#include "compiler.h"

#define DBG(x)

#define DEBUG_ALL (HAS_DEBUG_FULL || 0)
#define DEBUG_ACCEL (DEBUG_ALL || 0)
#define DEBUG_BATCH (DEBUG_ALL || 0)
#define DEBUG_BLT (DEBUG_ALL || 0)
#define DEBUG_COMPOSITE (DEBUG_ALL || 0)
#define DEBUG_DAMAGE (DEBUG_ALL || 0)
#define DEBUG_DISPLAY (DEBUG_ALL || 0)
#define DEBUG_DRI (DEBUG_ALL || 0)
#define DEBUG_DRIVER (DEBUG_ALL || 0)
#define DEBUG_GRADIENT (DEBUG_ALL || 0)
#define DEBUG_GLYPHS (DEBUG_ALL || 0)
#define DEBUG_IO (DEBUG_ALL || 0)
#define DEBUG_KGEM (DEBUG_ALL || 0)
#define DEBUG_RENDER (DEBUG_ALL || 0)
#define DEBUG_STREAM (DEBUG_ALL || 0)
#define DEBUG_TRAPEZOIDS (DEBUG_ALL || 0)
#define DEBUG_VIDEO (DEBUG_ALL || 0)
#define DEBUG_VIDEO_TEXTURED (DEBUG_ALL || 0)
#define DEBUG_VIDEO_OVERLAY (DEBUG_ALL || 0)

#define DEBUG_NO_RENDER 0
#define DEBUG_NO_BLT 0
#define DEBUG_NO_IO 0

#define DEBUG_FLUSH_CACHE 0
#define DEBUG_FLUSH_BATCH 0
#define DEBUG_FLUSH_SYNC 0

#define TEST_ALL 0
#define TEST_ACCEL (TEST_ALL || 0)
#define TEST_BATCH (TEST_ALL || 0)
#define TEST_BLT (TEST_ALL || 0)
#define TEST_COMPOSITE (TEST_ALL || 0)
#define TEST_DAMAGE (TEST_ALL || 0)
#define TEST_GRADIENT (TEST_ALL || 0)
#define TEST_GLYPHS (TEST_ALL || 0)
#define TEST_IO (TEST_ALL || 0)
#define TEST_KGEM (TEST_ALL || 0)
#define TEST_RENDER (TEST_ALL || 0)

#include "intel_driver.h"
#include "kgem.h"
#include "sna_damage.h"
#include "sna_render.h"

static inline void list_add_tail(struct list *new, struct list *head)
{
	__list_add(new, head->prev, head);
}

#ifndef CREATE_PIXMAP_USAGE_SCRATCH_HEADER
#define FAKE_CREATE_PIXMAP_USAGE_SCRATCH_HEADER 1
#define CREATE_PIXMAP_USAGE_SCRATCH_HEADER (unsigned)-1
#endif

#define SNA_CURSOR_X			64
#define SNA_CURSOR_Y			SNA_CURSOR_X

struct sna_pixmap {
	PixmapPtr pixmap;
	struct kgem_bo *gpu_bo, *cpu_bo;
	struct sna_damage *gpu_damage, *cpu_damage;

	struct list list;
	struct list inactive;

#define SOURCE_BIAS 4
	uint16_t source_count;
	uint8_t mapped :1;
	uint8_t pinned :1;
	uint8_t gpu_only :1;
	uint8_t flush :1;
	uint8_t gpu :1;
};

struct sna_glyph {
	PicturePtr atlas;
	pixman_image_t *image;
	struct sna_coordinate coordinate;
	uint16_t size, pos;
};

extern DevPrivateKeyRec sna_private_index;
extern DevPrivateKeyRec sna_pixmap_index;
extern DevPrivateKeyRec sna_gc_index;
extern DevPrivateKeyRec sna_glyph_key;

static inline PixmapPtr get_window_pixmap(WindowPtr window)
{
#if 0
	return window->drawable.pScreen->GetWindowPixmap(window)
#else
	return *(void **)window->devPrivates;
#endif
}

static inline PixmapPtr get_drawable_pixmap(DrawablePtr drawable)
{
	if (drawable->type == DRAWABLE_PIXMAP)
		return (PixmapPtr)drawable;
	else
		return get_window_pixmap((WindowPtr)drawable);
}

static inline struct sna_pixmap *sna_pixmap(PixmapPtr pixmap)
{
	return ((void **)pixmap->devPrivates)[1];
}

static inline struct sna_pixmap *sna_pixmap_from_drawable(DrawablePtr drawable)
{
	return sna_pixmap(get_drawable_pixmap(drawable));
}

struct sna_gc {
	long changes;
	long serial;
};

static inline struct sna_gc *sna_gc(GCPtr gc)
{
	return (struct sna_gc *)gc->devPrivates;
}

enum {
	OPTION_TILING_FB,
	OPTION_TILING_2D,
	OPTION_PREFER_OVERLAY,
	OPTION_COLOR_KEY,
	OPTION_VIDEO_KEY,
	OPTION_HOTPLUG,
	OPTION_THROTTLE,
	OPTION_RELAXED_FENCING,
	OPTION_VMAP,
	OPTION_ZAPHOD,
	OPTION_DELAYED_FLUSH,
	NUM_OPTIONS
};

enum {
	FLUSH_TIMER = 0,
	EXPIRE_TIMER,
	INACTIVE_TIMER,
	NUM_TIMERS
};
#define NUM_FINE_TIMERS 1

struct sna {
	ScrnInfoPtr scrn;

	unsigned flags;
#define SNA_NO_THROTTLE		0x1
#define SNA_NO_DELAYED_FLUSH	0x2

	int timer[NUM_TIMERS];
	int timer_active;

	int vblank_interval;

	struct list deferred_free;
	struct list dirty_pixmaps;
	struct list active_pixmaps;
	struct list inactive_clock[2];

	PixmapPtr front, shadow;
	PixmapPtr freed_pixmap;

	struct sna_mode {
		uint32_t fb_id;
		uint32_t fb_pixmap;
		drmModeResPtr mode_res;
		int cpp;

		struct list outputs;
		struct list crtcs;
	} mode;

	struct sna_dri {
		void *flip_pending[2];
	} dri;

	unsigned int tiling;
#define SNA_TILING_FB		0x1
#define SNA_TILING_2D		0x2
#define SNA_TILING_3D		0x4
#define SNA_TILING_ALL (~0)

	int Chipset;
	EntityInfoPtr pEnt;
	struct pci_device *PciInfo;
	struct intel_chipset chipset;

	ScreenBlockHandlerProcPtr BlockHandler;
	void *BlockData;
	ScreenWakeupHandlerProcPtr WakeupHandler;
	void *WakeupData;
	CloseScreenProcPtr CloseScreen;

	struct {
		uint32_t fill_bo;
		uint32_t fill_pixel;
		uint32_t fill_alu;
	} blt_state;
	union {
		struct gen2_render_state gen2;
		struct gen3_render_state gen3;
		struct gen4_render_state gen4;
		struct gen5_render_state gen5;
		struct gen6_render_state gen6;
		struct gen7_render_state gen7;
	} render_state;
	uint32_t have_render;
	uint32_t default_tiling;

	Bool directRenderingOpen;
	char *deviceName;

	/* Broken-out options. */
	OptionInfoPtr Options;

	/* Driver phase/state information */
	Bool suspended;

#if HAVE_UDEV
	struct udev_monitor *uevent_monitor;
	InputHandlerProc uevent_handler;
#endif

	struct kgem kgem;
	struct sna_render render;
};

Bool sna_mode_pre_init(ScrnInfoPtr scrn, struct sna *sna);
extern void sna_mode_remove_fb(struct sna *sna);
extern void sna_mode_fini(struct sna *sna);

extern int sna_crtc_id(xf86CrtcPtr crtc);
extern int sna_output_dpms_status(xf86OutputPtr output);

extern int sna_page_flip(struct sna *sna,
			 struct kgem_bo *bo,
			 void *data,
			 int ref_crtc_hw_id,
			 uint32_t *old_fb);

extern PixmapPtr sna_set_screen_pixmap(struct sna *sna, PixmapPtr pixmap);

void sna_mode_delete_fb(struct sna *sna, uint32_t fb);

static inline struct sna *
to_sna(ScrnInfoPtr scrn)
{
	return (struct sna *)(scrn->driverPrivate);
}

static inline struct sna *
to_sna_from_screen(ScreenPtr screen)
{
	return to_sna(xf86Screens[screen->myNum]);
}

static inline struct sna *
to_sna_from_pixmap(PixmapPtr pixmap)
{
	return *(void **)pixmap->devPrivates;
}

static inline struct sna *
to_sna_from_drawable(DrawablePtr drawable)
{
	return to_sna_from_screen(drawable->pScreen);
}

static inline struct sna *
to_sna_from_kgem(struct kgem *kgem)
{
	return container_of(kgem, struct sna, kgem);
}

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#endif
#define ALIGN(i,m)	(((i) + (m) - 1) & ~((m) - 1))
#define MIN(a,b)	((a) < (b) ? (a) : (b))

extern xf86CrtcPtr sna_covering_crtc(ScrnInfoPtr scrn,
				     const BoxRec *box,
				     xf86CrtcPtr desired,
				     BoxPtr crtc_box_ret);

extern bool sna_wait_for_scanline(struct sna *sna, PixmapPtr pixmap,
				  xf86CrtcPtr crtc, const BoxRec *clip);

Bool sna_dri_open(struct sna *sna, ScreenPtr pScreen);
void sna_dri_wakeup(struct sna *sna);
void sna_dri_close(struct sna *sna, ScreenPtr pScreen);

extern Bool sna_crtc_on(xf86CrtcPtr crtc);
int sna_crtc_to_pipe(xf86CrtcPtr crtc);

/* sna_render.c */
void sna_kgem_reset(struct kgem *kgem);
void sna_kgem_flush(struct kgem *kgem);
void sna_kgem_context_switch(struct kgem *kgem, int new_mode);

CARD32 sna_format_for_depth(int depth);

void sna_debug_flush(struct sna *sna);

static inline void
get_drawable_deltas(DrawablePtr drawable, PixmapPtr pixmap, int16_t *x, int16_t *y)
{
#ifdef COMPOSITE
	if (drawable->type == DRAWABLE_WINDOW) {
		*x = -pixmap->screen_x;
		*y = -pixmap->screen_y;
		return;
	}
#endif
	*x = *y = 0;
}

static inline int
get_drawable_dx(DrawablePtr drawable)
{
#ifdef COMPOSITE
	if (drawable->type == DRAWABLE_WINDOW)
		return -get_drawable_pixmap(drawable)->screen_x;
#endif
	return 0;
}

static inline int
get_drawable_dy(DrawablePtr drawable)
{
#ifdef COMPOSITE
	if (drawable->type == DRAWABLE_WINDOW)
		return -get_drawable_pixmap(drawable)->screen_y;
#endif
	return 0;
}

static inline Bool pixmap_is_scanout(PixmapPtr pixmap)
{
	ScreenPtr screen = pixmap->drawable.pScreen;
	return pixmap == screen->GetScreenPixmap(screen);
}

struct sna_pixmap *sna_pixmap_attach(PixmapPtr pixmap);

PixmapPtr sna_pixmap_create_upload(ScreenPtr screen,
				   int width, int height, int depth);

void sna_pixmap_move_to_cpu(PixmapPtr pixmap, bool write);
struct sna_pixmap *sna_pixmap_move_to_gpu(PixmapPtr pixmap);
struct sna_pixmap *sna_pixmap_force_to_gpu(PixmapPtr pixmap);

void
sna_drawable_move_region_to_cpu(DrawablePtr drawable,
				RegionPtr region,
				Bool write);

static inline void
sna_drawable_move_to_cpu(DrawablePtr drawable, bool write)
{
	RegionRec region;

	pixman_region_init_rect(&region,
				0, 0, drawable->width, drawable->height);
	sna_drawable_move_region_to_cpu(drawable, &region, write);
}

static inline Bool
sna_drawable_move_to_gpu(DrawablePtr drawable)
{
	return sna_pixmap_move_to_gpu(get_drawable_pixmap(drawable)) != NULL;
}

static inline Bool
sna_pixmap_is_gpu(PixmapPtr pixmap)
{
	struct sna_pixmap *priv = sna_pixmap(pixmap);
	return priv && priv->gpu_bo;
}

static inline struct kgem_bo *sna_pixmap_get_bo(PixmapPtr pixmap)
{
	return sna_pixmap(pixmap)->gpu_bo;
}

static inline struct kgem_bo *sna_pixmap_pin(PixmapPtr pixmap)
{
	struct sna_pixmap *priv;

	priv = sna_pixmap_force_to_gpu(pixmap);
	if (!priv)
		return NULL;

	priv->pinned = 1;
	return priv->gpu_bo;
}


static inline Bool
_sna_transform_point(const PictTransform *transform,
		     int64_t x, int64_t y, int64_t result[3])
{
	int j;

	for (j = 0; j < 3; j++)
		result[j] = (transform->matrix[j][0] * x +
			     transform->matrix[j][1] * y +
			     transform->matrix[j][2]);

	return result[2] != 0;
}

static inline void
_sna_get_transformed_coordinates(int x, int y,
				 const PictTransform *transform,
				 float *x_out, float *y_out)
{

	int64_t result[3];

	_sna_transform_point(transform, x, y, result);
	*x_out = result[0] / (double)result[2];
	*y_out = result[1] / (double)result[2];
}

void
sna_get_transformed_coordinates(int x, int y,
			       	const PictTransform *transform,
				float *x_out, float *y_out);

Bool
sna_get_transformed_coordinates_3d(int x, int y,
				   const PictTransform *transform,
				   float *x_out, float *y_out, float *z_out);

Bool sna_transform_is_affine(const PictTransform *t);
Bool sna_transform_is_integer_translation(const PictTransform *t,
					  int16_t *tx, int16_t *ty);
Bool sna_transform_is_translation(const PictTransform *t,
				  pixman_fixed_t *tx, pixman_fixed_t *ty);

static inline bool wedged(struct sna *sna)
{
	return unlikely(sna->kgem.wedged);
}

static inline uint32_t pixmap_size(PixmapPtr pixmap)
{
	return (pixmap->drawable.height - 1) * pixmap->devKind +
		pixmap->drawable.width * pixmap->drawable.bitsPerPixel/8;
}

static inline struct kgem_bo *pixmap_vmap(struct kgem *kgem, PixmapPtr pixmap)
{
	struct sna_pixmap *priv;

	if (unlikely(kgem->wedged))
		return NULL;

	priv = sna_pixmap_attach(pixmap);
	if (priv == NULL)
		return NULL;

	if (priv->cpu_bo == NULL) {
		priv->cpu_bo = kgem_create_map(kgem,
					       pixmap->devPrivate.ptr,
					       pixmap_size(pixmap),
					       0);
		if (priv->cpu_bo) {
			priv->cpu_bo->pitch = pixmap->devKind;
			if (pixmap->usage_hint == CREATE_PIXMAP_USAGE_SCRATCH_HEADER)
				priv->cpu_bo->sync = true;
		}
	}

	return priv->cpu_bo;
}

Bool sna_accel_pre_init(struct sna *sna);
Bool sna_accel_init(ScreenPtr sreen, struct sna *sna);
void sna_accel_block_handler(struct sna *sna);
void sna_accel_wakeup_handler(struct sna *sna);
void sna_accel_close(struct sna *sna);
void sna_accel_free(struct sna *sna);

Bool sna_accel_create(struct sna *sna);
void sna_copy_fbcon(struct sna *sna);

void sna_composite(CARD8 op,
		   PicturePtr src,
		   PicturePtr mask,
		   PicturePtr dst,
		   INT16 src_x,  INT16 src_y,
		   INT16 mask_x, INT16 mask_y,
		   INT16 dst_x,  INT16 dst_y,
		   CARD16 width, CARD16 height);
void sna_composite_rectangles(CARD8		 op,
			      PicturePtr		 dst,
			      xRenderColor	*color,
			      int			 num_rects,
			      xRectangle		*rects);
void sna_composite_trapezoids(CARD8 op,
			      PicturePtr src,
			      PicturePtr dst,
			      PictFormatPtr maskFormat,
			      INT16 xSrc, INT16 ySrc,
			      int ntrap, xTrapezoid *traps);
void sna_add_traps(PicturePtr picture, INT16 x, INT16 y, int n, xTrap *t);

void sna_composite_triangles(CARD8 op,
			     PicturePtr src,
			     PicturePtr dst,
			     PictFormatPtr maskFormat,
			     INT16 xSrc, INT16 ySrc,
			     int ntri, xTriangle *tri);

void sna_composite_tristrip(CARD8 op,
			    PicturePtr src,
			    PicturePtr dst,
			    PictFormatPtr maskFormat,
			    INT16 xSrc, INT16 ySrc,
			    int npoints, xPointFixed *points);

void sna_composite_trifan(CARD8 op,
			  PicturePtr src,
			  PicturePtr dst,
			  PictFormatPtr maskFormat,
			  INT16 xSrc, INT16 ySrc,
			  int npoints, xPointFixed *points);

Bool sna_gradients_create(struct sna *sna);
void sna_gradients_close(struct sna *sna);

Bool sna_glyphs_create(struct sna *sna);
void sna_glyphs(CARD8 op,
		PicturePtr src,
		PicturePtr dst,
		PictFormatPtr mask,
		INT16 xSrc, INT16 ySrc,
		int nlist,
		GlyphListPtr list,
		GlyphPtr *glyphs);
void sna_glyph_unrealize(ScreenPtr screen, GlyphPtr glyph);
void sna_glyphs_close(struct sna *sna);

void sna_read_boxes(struct sna *sna,
		    struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
		    PixmapPtr dst, int16_t dst_dx, int16_t dst_dy,
		    const BoxRec *box, int n);
void sna_write_boxes(struct sna *sna,
		     struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
		     const void *src, int stride, int bpp, int16_t src_dx, int16_t src_dy,
		     const BoxRec *box, int n);

struct kgem_bo *sna_replace(struct sna *sna,
			    PixmapPtr pixmap,
			    struct kgem_bo *bo,
			    const void *src, int stride);

Bool
sna_compute_composite_extents(BoxPtr extents,
			      PicturePtr src, PicturePtr mask, PicturePtr dst,
			      INT16 src_x,  INT16 src_y,
			      INT16 mask_x, INT16 mask_y,
			      INT16 dst_x,  INT16 dst_y,
			      CARD16 width, CARD16 height);
Bool
sna_compute_composite_region(RegionPtr region,
			     PicturePtr src, PicturePtr mask, PicturePtr dst,
			     INT16 src_x,  INT16 src_y,
			     INT16 mask_x, INT16 mask_y,
			     INT16 dst_x,  INT16 dst_y,
			     CARD16 width, CARD16 height);

void
memcpy_blt(const void *src, void *dst, int bpp,
	   int32_t src_stride, int32_t dst_stride,
	   int16_t src_x, int16_t src_y,
	   int16_t dst_x, int16_t dst_y,
	   uint16_t width, uint16_t height);

#define SNA_CREATE_FB 0x10
#define SNA_CREATE_SCRATCH 0x11

#endif /* _SNA_H */