1 '\" te
2 .\" Copyright (c) 2008, Sun Microsystems, Inc. All Rights Reserved
3 .\" The contents of this file are subject to the terms of the Common Development and Distribution License (the "License"). You may not use this file except in compliance with the License.
4 .\" You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE or http://www.opensolaris.org/os/licensing. See the License for the specific language governing permissions and limitations under the License.
5 .\" When distributing Covered Code, include this CDDL HEADER in each file and include the License file at usr/src/OPENSOLARIS.LICENSE. If applicable, add the following below this CDDL HEADER, with the fields enclosed by brackets "[]" replaced with your own identifying information: Portions Copyright [yyyy] [name of copyright owner]
6 .TH AGPGART_IO 7I "Sep 10, 2013"
7 .SH NAME
8 agpgart_io \- Solaris agpgart driver I/O control operations
9 .SH SYNOPSIS
10 .LP
11 .nf
12 #include <sys/agpgart.h>
13 .fi
14
15 .SH DESCRIPTION
16 .sp
17 .LP
18 The Accelerated Graphics Port (AGP) is a PCI bus technology enhancement that
19 improves 3D graphics performance by using low-cost system memory. AGP chipsets
20 use the Graphics Address Remapping Table (GART) to map discontiguous system
21 memory into a contiguous PCI memory range (known as the AGP Aperture), enabling
22 the graphics card to utilize the mapped aperture range as video memory.
23 .sp
24 .LP
25 The \fBagpgart\fR driver creates a pseudo device node at \fB/dev/agpgart\fR and
26 provides a set of ioctls for managing allocation/deallocation of system
27 memory, setting mappings between system memory and aperture range, and setting
28 up AGP devices. The \fBagpgart\fR driver manages both pseudo and real device
29 nodes, but to initiate AGP-related operations you operate only on the
30 \fB/dev/agpgart\fR pseudo device node. To do this, open \fB/dev/agpgart\fR. The
31 macro defined for the pseudo device node name is:
32 .sp
33 .in +2
34 .nf
35 #define AGP_DEVICE "/dev/agpgart"
36 .fi
37 .in -2
38
39 .sp
40 .LP
41 The \fBagpgart_io\fR driver implementation is AGP architecture-dependent and
42 cannot be made generic. Currently, the \fBagpgart_io\fR driver only supports
43 specific AGP systems. To determine if a system is supported, run an
44 \fBopen\fR(2) system call on the AGP_DEVICE node. (Note that \fBopen\fR(2)
45 fails if a system is not supported). After the AGP_DEVICE is opened, you can
46 use \fBkstat\fR(1M) to read the system architecture type.
47 .sp
48 .LP
49 In addition to AGP system support, the \fBagpgart\fR ioctls can also be used on
50 Intel integrated graphics devices (IGD). IGD devices usually have no dedicated
51 video memory and must use system memory as video memory. IGD devices contain
52 translation tables (referred to as \fBGTT\fR tables) that are similar to the
53 GART translation table for address mapping purposes.
54 .sp
55 .LP
56 Processes must open the \fBagpgart_io\fR driver utilizing a GRAPHICS_ACCESS
57 privilege. Then all the ioctls can be called by this processes with the saved
58 file descriptor. With the exception of AGPIOC_INFO, the AGPIOC_ACQUIRE ioctl
59 must be called before any other ioctl. Once a process has acquired GART, it
60 cannot be acquired by another process until the former process calls
61 AGPIOC_RELEASE.
62 .sp
63 .LP
64 If the AGP_DEVICE fails to open, it may be due to one of the following reasons:
65 .sp
66 .ne 2
67 .na
68 \fBEAGAIN\fR
69 .ad
70 .sp .6
71 .RS 4n
72 GART table allocation failed.
73 .RE
74
75 .sp
76 .ne 2
77 .na
78 \fBEIO\fR
79 .ad
80 .sp .6
81 .RS 4n
82 Internal hardware initialization failed.
83 .RE
84
85 .sp
86 .ne 2
87 .na
88 \fBENXIO\fR
89 .ad
90 .sp .6
91 .RS 4n
92 Getting device soft state error. (This is unlikely to happen.)
93 .RE
94
95 .sp
96 .ne 2
97 .na
98 \fB EPERM\fR
99 .ad
100 .sp .6
101 .RS 4n
102 Without enough privilege.
103 .RE
104
105 .SH IOCTLS
106 .sp
107 .LP
108 With the exception of GPIOC_INFO, all ioctls shown in this section are
109 protected by GRAPHICS_ACCESS privilege. (Only processes with GRAPHICS_ACCESS
110 privilege in its effective set can access the privileged ioctls).
111 .sp
112 .LP
113 Common ioctl error codes are shown below. (Additional error codes may be
114 displayed by individual ioctls.)
115 .sp
116 .ne 2
117 .na
118 \fBENXIO\fR
119 .ad
120 .sp .6
121 .RS 4n
122 Ioctl command not supported or getting device soft state error.
123 .RE
124
125 .sp
126 .ne 2
127 .na
128 \fBEPERM\fR
129 .ad
130 .sp .6
131 .RS 4n
132 Process not privileged.
133 .RE
134
135 .sp
136 .ne 2
137 .na
138 \fB\fBAGPIOC_INFO\fR\fR
139 .ad
140 .sp .6
141 .RS 4n
142 Get system wide AGP or IGD hardware information. This command can be called by
143 any process from user or kernel context.
144 .sp
145 .in +2
146 .nf
147 The argument is a pointer to agp_info_t structure.
148
149 typedef struct _agp_info {
150 agp_version_t agpi_version; /* OUT: AGP version supported */
151 uint32_t agpi_devid; /* OUT: bridge vendor + device */
152 uint32_t agpi_mode; /* OUT: mode of bridge */
153 ulong_t agpi_aperbase; /* OUT: base of aperture */
154 size_t agpi_apersize; /* OUT: aperture size in MB */
155 uint32_t agpi_pgtotal; /* OUT: max aperture pages avail. */
156 uint32_t agpi_pgsystem; /* OUT: same as pg_total */
157 uint32_t agpi_pgused; /* OUT: no. of currently used pages */
158 } agp_info_t;
159
160 agpi_version The version of AGP protocol the bridge device is
161 compatible with, for example, major 3 and minor 0
162 means AGP version 3.0.
163
164 typedef struct _agp_version {
165 uint16_t agpv_major;
166 uint16_t agpv_minor;
167 } agp_version_t;
168
169 agpi_devid AGP bridge vendor and device ID.
170 agpi_mode Current AGP mode, read from AGP status register of
171 target device. The main bits are defined as below.
172 /* AGP status register bits definition */
173
174 #define AGPSTAT_RQ_MASK 0xff000000
175 #define AGPSTAT_SBA (0x1 << 9)
176 #define AGPSTAT_OVER4G (0x1 << 5)
177 #define AGPSTAT_FW (0x1 << 4)
178 #define AGPSTAT_RATE_MASK 0x7
179 /* AGP 3.0 only bits */
180 #define AGPSTAT_ARQSZ_MASK (0x7 << 13)
181 #define AGPSTAT_CAL_MASK (0x7 << 10)
182 #define AGPSTAT_GART64B (0x1 << 7)
183 #define AGPSTAT_MODE3 (0x1 << 3)
184 /* rate for 2.0 mode */
185 #define AGP2_RATE_1X 0x1
186 #define AGP2_RATE_2X 0x2
187 #define AGP2_RATE_4X 0x4
188 /* rate for 3.0 mode */
189 #define AGP3_RATE_4X 0x1
190 #define AGP3_RATE_8X 0x2
191
192 agpi_aperbase The base address of aperture in PCI memory space.
193 agpi_apersize The size of the aperture in megabytes.
194 agpi_pgtotal Represents the maximum memory
195 pages the system can allocate
196 according to aperture size and
197 system memory size (which may differ
198 from the maximum locked memory a process
199 can have. The latter is subject
200 to the memory resource limit imposed
201 by the resource_controls(5) for each
202 project(4)):
203
204 project.max-device-locked-memory
205
206 This value can be modified through system
207 utilities like prctl(1).
208
209 agpi_pgsystem Same as pg_total.
210 agpi_pgused System pages already allocated by the driver.
211
212 Return Values:
213
214 EFAULT Argument copy out error
215 EINVAL Command invalid
216 0 Success
217 .fi
218 .in -2
219
220 .RE
221
222 .sp
223 .ne 2
224 .na
225 \fB\fBAGPIOC_ACQUIRE\fR\fR
226 .ad
227 .sp .6
228 .RS 4n
229 Acquire control of GART. With the exception of AGPIOC_INFO, a process must
230 acquire GART before can it call other agpgart ioctl commands. Additionally,
231 only processes with GRAPHICS_ACCESS privilege may access this ioctl. In the
232 current agpgart implementation, GART access is exclusive, meaning that only one
233 process can perform GART operations at a time. To release control over GART,
234 call AGPIOC_RELEASE. This command can be called from user or kernel context.
235 .sp
236 The argument should be NULL.
237 .sp
238 Return values:
239 .sp
240 .ne 2
241 .na
242 \fBEBUSY\fR
243 .ad
244 .RS 9n
245 GART has been acquired
246 .RE
247
248 .sp
249 .ne 2
250 .na
251 \fB0\fR
252 .ad
253 .RS 9n
254 Success.
255 .RE
256
257 .RE
258
259 .sp
260 .ne 2
261 .na
262 \fB\fBAGPIOC_RELEASE\fR\fR
263 .ad
264 .sp .6
265 .RS 4n
266 Release GART control. If a process releases GART control, it cannot perform
267 additional GART operations until GART is reacquired. Note that this command
268 does not free allocated memory or clear GART entries. (All clear jobs are done
269 by direct calls or by closing the device). When a process exits without making
270 this ioctl, the final \fBclose\fR(2) performs this automatically. This command
271 can be called from user or kernel context.
272 .sp
273 The argument should be NULL.
274 .sp
275 Return values:
276 .sp
277 .ne 2
278 .na
279 \fBEPERM\fR
280 .ad
281 .RS 9n
282 Not owner of GART.
283 .RE
284
285 .sp
286 .ne 2
287 .na
288 \fB0\fR
289 .ad
290 .RS 9n
291 Success.
292 .RE
293
294 .RE
295
296 .sp
297 .ne 2
298 .na
299 \fB\fBAGPIOC_SETUP\fR\fR
300 .ad
301 .sp .6
302 .RS 4n
303 Setup AGPCMD register. An AGPCMD register resides in both the AGP master and
304 target devices. The AGPCMD register controls the working mode of the AGP master
305 and target devices. Each device must be configured using the same mode. This
306 command can be called from user or kernel context.
307 .sp
308 .in +2
309 .nf
310 The argument is a pointer to agp_setup_t structure:
311
312 typedef struct _agp_setup {
313 uint32_t agps_mode; /* IN: value to be set for AGPCMD */
314 } agp_setup_t;
315
316 agps_mode Specifying the mode to be set. Each bit of the value may have
317 a specific meaning, please refer to AGP 2.0/3.0 specification
318 or hardware datasheets for details.
319
320 /* AGP command register bits definition */
321 #define AGPCMD_RQ_MASK 0xff000000
322 #define AGPCMD_SBAEN (0x1 << 9)
323 #define AGPCMD_AGPEN (0x1 << 8)
324 #define AGPCMD_OVER4GEN (0x1 << 5)
325 #define AGPCMD_FWEN (0x1 << 4)
326 #define AGPCMD_RATE_MASK 0x7
327 /* AGP 3.0 only bits */
328 #define AGP3_CMD_ARQSZ_MASK (0x7 << 13)
329 #define AGP3_CMD_CAL_MASK (0x7 << 10)
330 #define AGP3_CMD_GART64BEN (0x1 << 7)
331 .fi
332 .in -2
333
334 The final values set to the AGPCMD register of the master/target devices are
335 decided by the agps_mode value and AGPSTAT of the master and target devices.
336 .sp
337 Return Values:
338 .sp
339 .ne 2
340 .na
341 \fBEPERM\fR
342 .ad
343 .RS 10n
344 Not owner of GART.
345 .RE
346
347 .sp
348 .ne 2
349 .na
350 \fBEFAULT\fR
351 .ad
352 .RS 10n
353 Argument copy in error.
354 .RE
355
356 .sp
357 .ne 2
358 .na
359 \fBEINVAL\fR
360 .ad
361 .RS 10n
362 Command invalid for non-AGP system.
363 .RE
364
365 .sp
366 .ne 2
367 .na
368 \fBEIO\fR
369 .ad
370 .RS 10n
371 Hardware setup error.
372 .RE
373
374 .sp
375 .ne 2
376 .na
377 \fB0\fR
378 .ad
379 .RS 10n
380 Success.
381 .RE
382
383 .RE
384
385 .sp
386 .ne 2
387 .na
388 \fB\fBAGPIOC_ALLOCATE\fR\fR
389 .ad
390 .sp .6
391 .RS 4n
392 Allocate system memory for graphics device. This command returns a unique ID
393 which can be used in subsequent operations to represent the allocated memory.
394 The memory is made up of discontiguous physical pages. In rare cases, special
395 memory types may be required. The allocated memory must be bound to the GART
396 table before it can be used by graphics device. Graphics applications can also
397 \fBmmap\fR(2) the memory to userland for data storing. Memory should be freed
398 when it is no longer used by calling AGPIOC_DEALLOCATE or simply by closing the
399 device. This command can be called from user or kernel context.
400 .sp
401 .in +2
402 .nf
403 The argument is a pointer to agp_allocate_t structure.
404
405 typedef struct _agp_allocate {
406 int32_t agpa_key; /* OUT:ID of allocated memory */
407 uint32_t agpa_pgcount;/* IN: no. of pages to be allocated */
408 uint32_t agpa_type;/* IN: type of memory to be allocated */
409 uint32_t agpa_physical; /* OUT: reserved */
410 } agp_allocate_t;
411 .fi
412 .in -2
413
414 .sp
415 .ne 2
416 .na
417 \fBagpa_key\fR
418 .ad
419 .RS 21n
420 Unique ID of the allocated memory.
421 .RE
422
423 .sp
424 .ne 2
425 .na
426 \fBagpa_pgcount\fR
427 .ad
428 .RS 21n
429 Number of pages to be allocated. The driver currently supports only 4K pages.
430 The value cannot exceed the agpi_pgtotal value returned by AGPIOC_INFO ioct and
431 is subject to the limit of project.max-device-locked-memory. If the memory
432 needed is larger than the resource limit but not larger than agpi_pgtotal, use
433 \fBprctl\fR(1) or other system utilities to change the default value of memory
434 resource limit beforehand.
435 .RE
436
437 .sp
438 .ne 2
439 .na
440 \fBagpa_type\fR
441 .ad
442 .RS 21n
443 Type of memory to be allocated. The valid value of agpa_type should be
444 AGP_NORMAL. It is defined as:
445 .sp
446 .in +2
447 .nf
448 #define AGP_NORMAL 0
449 .fi
450 .in -2
451
452 Above, AGP_NORMAL represents the discontiguous non-cachable physical memory
453 which doesn't consume kernel virtual space but can be mapped to user space by
454 \fBmmap\fR(2). This command may support more type values in the future.
455 .RE
456
457 .sp
458 .ne 2
459 .na
460 \fBagpa_physical\fR
461 .ad
462 .RS 21n
463 Reserved for special uses. In normal operations, the value is undefined.
464 .sp
465 Return Values:
466 .sp
467 .ne 2
468 .na
469 \fBEPERM\fR
470 .ad
471 .RS 10n
472 Not owner of GART.
473 .RE
474
475 .sp
476 .ne 2
477 .na
478 \fBEINVAL\fR
479 .ad
480 .RS 10n
481 Argument not valid.
482 .RE
483
484 .sp
485 .ne 2
486 .na
487 \fBEFAULT\fR
488 .ad
489 .RS 10n
490 Argument copy in/out error.
491 .RE
492
493 .sp
494 .ne 2
495 .na
496 \fBENOMEM\fR
497 .ad
498 .RS 10n
499 Memory allocation error.
500 .RE
501
502 .sp
503 .ne 2
504 .na
505 \fB0\fR
506 .ad
507 .RS 10n
508 Success.
509 .RE
510
511 .RE
512
513 .sp
514 .ne 2
515 .na
516 \fBAGPIOC_DEALLOCATE\fR
517 .ad
518 .RS 21n
519 Deallocate the memory identified by a key assigned in a previous allocation. If
520 the memory isn't unbound from GART, this command unbinds it automatically. The
521 memory should no longer be used and those still in mapping to userland cannot
522 be deallocated. Always call AGPIOC_DEALLOCATE explicitly (instead of
523 deallocating implicitly by closing the device), as the system won't carry out
524 the job until the last reference to the device file is dropped. This command
525 from user or kernel context.
526 .sp
527 The input argument is a key of type int32_t, no output argument.
528 .sp
529 Return Values:
530 .sp
531 .ne 2
532 .na
533 \fBEPERM\fR
534 .ad
535 .RS 10n
536 Not owner of GART.
537 .RE
538
539 .sp
540 .ne 2
541 .na
542 \fBEINVAL\fR
543 .ad
544 .RS 10n
545 Key not valid or memory in use.
546 .RE
547
548 .sp
549 .ne 2
550 .na
551 \fB0\fR
552 .ad
553 .RS 10n
554 Success.
555 .RE
556
557 .RE
558
559 .sp
560 .ne 2
561 .na
562 \fBAGPIOC_BIND\fR
563 .ad
564 .RS 21n
565 Bind allocated memory. This command binds the allocated memory identified
566 by a key to a specific offset of the GART table, which enables GART to
567 translate the aperture range at the offset to system memory. Each GART entry
568 represents one physical page. If the GART range is previously bound to other
569 system memory, it returns an error. Once the memory is bound, it cannot be
570 bound to other offsets unless it is unbound. To unbind the memory, call
571 AGPIOC_UNBIND or deallocate the memory. This command can be called from user or
572 kernel context.
573 .sp
574 .in +2
575 .nf
576 The argument is a pointer to agp_bind_t structure:
577
578 typedef struct _agp_bind {
579 int32_t agpb_key; /* IN: ID of memory to be bound */
580 uint32_t agpb_pgstart; /* IN: offset in aperture */
581 } agp_bind_t;
582 .fi
583 .in -2
584
585 .sp
586 .ne 2
587 .na
588 \fBagpb_key\fR
589 .ad
590 .RS 20n
591 The unique ID of the memory to be bound, which is previously allocated by
592 calling AGPIOC_ALLOCATE.
593 .RE
594
595 .sp
596 .ne 2
597 .na
598 \fBagpb_pgstart\fR
599 .ad
600 .RS 20n
601 The starting page offset to be bound in aperture space.
602 .RE
603
604 Return Values:
605 .sp
606 .ne 2
607 .na
608 \fBEPERM\fR
609 .ad
610 .RS 20n
611 Not owner of GART.
612 .RE
613
614 .sp
615 .ne 2
616 .na
617 \fBEFAULT\fR
618 .ad
619 .RS 20n
620 Argument copy in error.
621 .RE
622
623 .sp
624 .ne 2
625 .na
626 \fBEINVAL\fR
627 .ad
628 .RS 20n
629 Argument not valid.
630 .RE
631
632 .sp
633 .ne 2
634 .na
635 \fBEIO\fR
636 .ad
637 .RS 20n
638 Binding to the GTT table of IGD devices failed.
639 .RE
640
641 .sp
642 .ne 2
643 .na
644 \fB0\fR
645 .ad
646 .RS 20n
647 Success.
648 .RE
649
650 .RE
651
652 .sp
653 .ne 2
654 .na
655 \fBAGPIOC_UNBIND\fR
656 .ad
657 .RS 21n
658 Unbind memory identified by a key from the GART. This command clears the
659 corresponding entries in the GART table. Only the memory not in mapping to
660 userland is allowed to be unbound.
661 .sp
662 This ioctl command can be called from user or kernel context.
663 .sp
664 .in +2
665 .nf
666 The argument is a pointer to agp_unbind_t structure.
667
668 typedef struct _agp_unbind {
669 int32_t agpu_key; /* IN: key of memory to be unbound*/
670 uint32_t agpu_pri; /* Not used: for compat. with Xorg */
671 } agp_unbind_t;
672 .fi
673 .in -2
674
675 .sp
676 .ne 2
677 .na
678 \fBagpu_key\fR
679 .ad
680 .RS 20n
681 Unique ID of the memory to be unbound which was previously bound by calling
682 AGPIOC_BIND.
683 .RE
684
685 .sp
686 .ne 2
687 .na
688 \fBagpu_pri\fR
689 .ad
690 .RS 20n
691 Reserved for compatibility with X.org/XFree86, not used.
692 .RE
693
694 Return Values:
695 .sp
696 .ne 2
697 .na
698 \fBEPERM\fR
699 .ad
700 .RS 20n
701 Not owner of GART.
702 .RE
703
704 .sp
705 .ne 2
706 .na
707 \fBEFAULT\fR
708 .ad
709 .RS 20n
710 Argument copy in error.
711 .RE
712
713 .sp
714 .ne 2
715 .na
716 \fBEINVAL\fR
717 .ad
718 .RS 20n
719 Argument not valid or memory in use.
720 .RE
721
722 .sp
723 .ne 2
724 .na
725 \fBEIO\fR
726 .ad
727 .RS 20n
728 Unbinding from the GTT table of IGD devices failed.
729 .RE
730
731 .sp
732 .ne 2
733 .na
734 \fB0\fR
735 .ad
736 .RS 20n
737 Success
738 .RE
739
740 .RE
741
742 .RE
743
744 .SH EXAMPLE
745 .sp
746 .LP
747 Below is an sample program showing how agpgart ioctls can be used:
748 .sp
749 .in +2
750 .nf
751 #include <stdio.h>
752 #include <stdlib.h>
753 #include <unistd.h
754 #include <sys/ioccom.h>
755 #include <sys/types.h>
756 #include <fcntl.h>
757 #include <errno.h>
758 #include <sys/mman.h>
759 #include <sys/agpgart.h>
760
761 #define AGP_PAGE_SIZE 4096
762
763 int main(int argc, char *argv[])
764 {
765 int fd, ret;
766 agp_allocate_t alloc;
767 agp_bind_t bindinfo;
768 agp_info_t agpinfo;
769 agp_setup_t modesetup;
770 int *p = NULL;
771 off_t mapoff;
772 size_t maplen;
773
774 if((fd = open(AGP_DEVICE, O_RDWR))== -1) {
775 printf("open AGP_DEVICE error with %d\en", errno);\e
776 exit(-1);
777 }
778 printf("device opened\en");
779
780 ret = ioctl(fd, AGPIOC_INFO, &agpinfo);
781 if(ret == -1) {
782 printf("Get info error %d\en", errno);
783 exit(-1);
784 }
785 printf("AGPSTAT is %x\en", agpinfo.agpi_mode);
786 printf("APBASE is %x\en", agpinfo.agpi_aperbase);
787 printf("APSIZE is %dMB\en", agpinfo.agpi_apersize);
788 printf("pg_total is %d\en", agpinfo.agpi_pgtotal);
789
790 ret = ioctl(fd, AGPIOC_ACQUIRE);
791 if(ret == -1) {
792 printf(" Acquire GART error %d\en", errno);
793 exit(-1);
794 }
795
796 modesetup.agps_mode = agpinfo.agpi_mode;
797 ret = ioctl(fd, AGPIOC_SETUP, &modesetup);
798 if(ret == -1) {
799 printf("set up AGP mode error\en", errno);
800 exit(-1);
801 }
802
803 printf("Please input the number of pages you want to allocate\en");
804 scanf("%d", &alloc.agpa_pgcount);
805 alloc.agpa_type = AGP_NORMAL;
806 ret = ioctl(fd, AGPIOC_ALLOCATE, &alloc);
807 if(ret == -1) {
808 printf("Allocate memory error %d\en", errno);
809 exit(-1);
810 }
811
812 printf("Please input the aperture page offset to bind\en");
813 scanf("%d", &bindinfo.agpb_pgstart);
814 bindinfo.agpb_key = alloc.agpa_key;
815 ret = ioctl(fd, AGPIOC_BIND, &bindinfo);
816 if(ret == -1) {
817 printf("Bind error %d\en", errno);
818 exit(-1);
819 }
820 printf("Bind successful\en");
821
822 /*
823 * Now gart aperture space from (bindinfo.agpb_pgstart) to
824 * (bindinfo.agpb_pgstart + alloc.agpa_pgcount) can be used for
825 * AGP graphics transactions
826 */
827 ...
828
829 /*
830 * mmap can allow user processes to store graphics data
831 * to the aperture space
832 */
833 maplen = alloc.agpa_pgcount * AGP_PAGE_SIZE;
834 mapoff = bindinfo.agpb_pgstart * AGP_PAGE_SIZE;
835 p = (int *)mmap((caddr_t)0, maplen, (PROT_READ | PROT_WRITE),
836 MAP_SHARED, fd, mapoff);
837 if (p == MAP_FAILED) {
838 printf("Mmap error %d\en", errno);
839 exit(-1);
840 }
841 printf("Mmap successful\en");
842 ...
843
844 /*
845 * When user processes finish access to the aperture space,
846 * unmap the memory range
847 */
848 munmap((void *)p, maplen);
849 ...
850
851 /*
852 * After finishing AGP transactions, the resources can be freed
853 * step by step or simply by close device.
854 */
855 ret = ioctl(fd, AGPIOC_DEALLOCATE, alloc.agpa_key);
856 if(ret == -1) {
857 printf(" Deallocate memory error %d\en", errno);
858 exit(-1);
859 }
860
861 ret = ioctl(fd, AGPIOC_RELEASE);
862 if(ret == -1) {
863 printf(" Release GART error %d\en", errno);
864 exit(-1);
865 }
866
867 close(fd);
868 }
869 .fi
870 .in -2
871
872 .SH FILES
873 .sp
874 .ne 2
875 .na
876 \fB\fB/dev/agpgart\fR\fR
877 .ad
878 .sp .6
879 .RS 4n
880 Symbolic link to the pseudo agpgart device.
881 .RE
882
883 .sp
884 .ne 2
885 .na
886 \fB\fB/platform/i86pc/kernel/drv/agpgart\fR\fR
887 .ad
888 .sp .6
889 .RS 4n
890 agpgart pseudo driver.
891 .RE
892
893 .sp
894 .ne 2
895 .na
896 \fB\fB/platform/i86pc/kernel/drv/agpgart.conf\fR\fR
897 .ad
898 .sp .6
899 .RS 4n
900 Driver configuration file.
901 .RE
902
903 .SH ATTRIBUTES
904 .sp
905 .LP
906 See \fBattributes\fR(5) for descriptions of the following attributes:
907 .sp
908
909 .sp
910 .TS
911 box;
912 c | c
913 l | l .
914 ATTRIBUTE TYPE ATTRIBUTE VALUE
915 _
916 Architecture X86
917 _
918 Stability level Unstable
919 .TE
920
921 .SH SEE ALSO
922 .sp
923 .LP
924 \fBprctl\fR(1), \fBkstat\fR(1M), \fBclose\fR(2), \fBioctl\fR(2), \fBopen\fR(2),
925 \fBmmap\fR(2), \fBproject\fR(4), \fBprivileges\fR(5), \fBattributes\fR(5),
926 \fBresource_controls\fR(5)