Return to qduser.h CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba

Annotation of 43BSDReno/sys/vaxuba/qduser.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *             @(#)qduser.h    1.4  Berkeley  6/3/88
        !             7:  */
        !             8: /* derived from: @(#)qduser.h  6.1     (ULTRIX)        11/24/87       */
        !             9: /************************************************************************
        !            10:  *                                                                     *
        !            11:  *                     Copyright (c) 1986 by                           *
        !            12:  *             Digital Equipment Corporation, Maynard, MA              *
        !            13:  *                     All rights reserved.                            *
        !            14:  *                                                                     *
        !            15:  *   This software is furnished under a license and may be used and    *
        !            16:  *   copied  only  in accordance with the terms of such license and    *
        !            17:  *   with the  inclusion  of  the  above  copyright  notice.   This    *
        !            18:  *   software  or  any  other copies thereof may not be provided or    *
        !            19:  *   otherwise made available to any other person.  No title to and    *
        !            20:  *   ownership of the software is hereby transferred.                  *
        !            21:  *                                                                     *
        !            22:  *   The information in this software is subject to change  without    *
        !            23:  *   notice  and should not be construed as a commitment by Digital    *
        !            24:  *   Equipment Corporation.                                            *
        !            25:  *                                                                     *
        !            26:  *   Digital assumes no responsibility for the use  or  reliability    *
        !            27:  *   of its software on equipment which is not supplied by Digital.    *
        !            28:  *                                                                     *
        !            29:  ************************************************************************/
        !            30: 
        !            31: /***************************************************************************
        !            32: *
        !            33: *      QDUSER...
        !            34: *      This file defines values shared between the driver and a client
        !            35: *
        !            36: ***************************************************************************/
        !            37: 
        !            38: /***************************************************************************
        !            39: *      revision history:
        !            40: ****************************************************************************
        !            41: *
        !            42: * 21 jul 86  ram    fixed define of CURSOR_MIN_Y
        !            43: * 25 nov 85  longo  added macro and bit defines for DMA error flags
        !            44: * 11 nov 85  longo  renamed _vs_eventqueue to "qdinput" struct
        !            45: * 23 oct 85  longo  added more defines to the DMA stuff
        !            46: * 17 oct 85  longo  changed "struct rgb" chars to be unsigned
        !            47: * 16 oct 85  longo  added new TABLET support definitions
        !            48: * 15 oct 85  longo  re-wrote DMA queue access macros
        !            49: * 08 oct 85  longo  added status flag manipulation macros to DMA stuff
        !            50: * 02 oct 85  longo  added support for color map write buffer loading
        !            51: * 26 sep 85  longo  removed adder sertup params from DMA request struct
        !            52: * 23 sep 85  longo  added DMA queue access macros
        !            53: * 30 aug 85  longo  fixed crock in "qdiobuf" struct compile-time sizing. Also
        !            54: *                  removed DMAcontrol struct from DMA buffer for field test
        !            55: * 26 aug 85  longo  put in conditional include of "qevent.h" for user prg's
        !            56: * 18 jul 85  longo  changed semantics so that head is tail and tail is head
        !            57: * 12 jul 85  longo  moved "mouse_report" struct and defs over to qd_data.c
        !            58: * 11 jul 85  longo  added device coordinate to gate array cursor coordinate
        !            59: *                  transformation macros
        !            60: * 03 jul 85  longo  changed kernel typdef's for data types to long-hand
        !            61: * 10 may 85  longo  created
        !            62: *
        !            63: ***************************************************************************/
        !            64: 
        !            65: #ifdef KERNEL
        !            66: #include "qevent.h"            /* include event struct defs */
        !            67: #else
        !            68: #include <vaxuba/qevent.h>
        !            69: #endif
        !            70: 
        !            71: /*---------------------
        !            72: * QDSS device map */
        !            73: 
        !            74:        struct qdmap {                  /* map of register blocks in QDSS */
        !            75: 
        !            76:            char *template;
        !            77:            char *adder;
        !            78:            char *dga;
        !            79:            char *duart;
        !            80:            char *memcsr;
        !            81:            char *red;
        !            82:            char *blue;
        !            83:            char *green;
        !            84:        };
        !            85: 
        !            86: /*--------------------------------------------
        !            87: * DGA CSR bit definitions and register map */
        !            88: 
        !            89: #define DMADONE                0x8000          /* DMA done status */
        !            90: #define SET_DONE_FIFO  0x4000          /* set DMADONE when FIFO empty.. */
        !            91:                                        /* ..AND count = 0 */
        !            92: 
        !            93: #define PTOB_ENB       0x0600          /* host-to-bitmap DMA xfer */
        !            94: #define BTOP_ENB       0x0400          /* bitmap-to-host DMA xfer */
        !            95: #define DL_ENB         0x0200          /* display list DMA xfer */
        !            96: #define HALT           0x0000          /* halt DGA */
        !            97: 
        !            98: #define BYTE_DMA       0x0100          /* byte/word DMA xfer */
        !            99: 
        !           100: #define DMA_ERR                0x0080          /* DMA error bits */
        !           101: #define PARITY_ERR     0x0040          /* memory parity error in DMA */
        !           102: #define BUS_ERR                0x0020          /* bus timeout error in DMA */
        !           103: 
        !           104: #define GLOBAL_IE      0x0004          /* global interrupt enable */
        !           105: #define DMA_IE         0x0002          /* DMA interrupt enable */
        !           106: #define CURS_ENB       0x0001          /* cursor enable */
        !           107: 
        !           108: /* QDSS memcsr bit definitions */
        !           109: 
        !           110: #define        UNBLANK                 0x0020
        !           111: #define SYNC_ON                        0x0008
        !           112: 
        !           113:        struct dga {
        !           114: 
        !           115:            unsigned short csr;
        !           116:            unsigned short adrs_lo;     /* destination address of bitmap to */
        !           117:            unsigned short adrs_hi;     /*   host DMA */
        !           118:            unsigned short bytcnt_lo;   /* byte length of requested DMA */
        !           119:            unsigned short bytcnt_hi;   /* (WO = bytcnt) (RO = fifo count) */
        !           120:            unsigned short fifo;        /* FIFO register */
        !           121:            unsigned short x_cursor;    /* cursor position registers */
        !           122:            unsigned short y_cursor;
        !           123:            unsigned short ivr;         /* interrupt vector register */
        !           124:            unsigned short memadr;      /* memory base address register */
        !           125:        };
        !           126: 
        !           127: /*-------------------------------------------------------------------------
        !           128: * macros to transform device coordinates to hardware cursor coordinates */
        !           129: 
        !           130: #define CURS_MIN_X     232     /* device coordinate x = 0 */
        !           131: #define CURS_MIN_Y     16      /* device coordinate y = 0 */
        !           132: 
        !           133: #define TRANX(x) ( -(((int)(x)+CURS_MIN_X) & ~0x0003) | \
        !           134:                   (((int)(x)+CURS_MIN_X) & 0x0003) )
        !           135: 
        !           136: #define TRANY(y) ( -((y)+CURS_MIN_Y) )
        !           137: 
        !           138: /*********************************************************************
        !           139: *
        !           140: *      EVENT QUEUE DEFINITIONS
        !           141: *
        !           142: **********************************************************************
        !           143: * most of the event queue definitions are found in "qevent.h".  But a
        !           144: * few things not found there are here.  */     
        !           145: 
        !           146: /* The event queue header */
        !           147:        
        !           148: typedef struct qdinput {
        !           149: 
        !           150:            struct _vs_eventqueue header;  /* event queue ring handling */
        !           151: 
        !           152:            /* for VS100 and QVSS compatability reasons, additions to this
        !           153:            *  structure must be made below this point.  */
        !           154: 
        !           155:            struct _vs_cursor curs_pos; /* current mouse position */
        !           156:            struct _vs_box curs_box;    /* cursor reporting box */
        !           157: 
        !           158:        };
        !           159:        
        !           160: /* vse_key field.  definitions for mouse buttons */
        !           161: 
        !           162: #define VSE_LEFT_BUTTON                0
        !           163: #define VSE_MIDDLE_BUTTON      1
        !           164: #define VSE_RIGHT_BUTTON       2
        !           165: 
        !           166: /* vse_key field.  definitions for mouse buttons */
        !           167: 
        !           168: #define VSE_T_LEFT_BUTTON      0
        !           169: #define VSE_T_FRONT_BUTTON     1
        !           170: #define VSE_T_RIGHT_BUTTON     2
        !           171: #define VSE_T_BACK_BUTTON      4
        !           172: 
        !           173: #define VSE_T_BARREL_BUTTON    VSE_T_LEFT_BUTTON
        !           174: #define VSE_T_TIP_BUTTON       VSE_T_FRONT_BUTTON
        !           175: 
        !           176: /*--------------------------------------------------------------------------
        !           177: *   These are the macros to be used for loading and extracting from the event
        !           178: * queue.  It is presumed that the macro user will only use the access macros
        !           179: * if the event queue is non-empty ( ISEMPTY(eq) == FALSE ), and that the
        !           180: * driver will only load the event queue after checking that it is not full
        !           181: * ( ISFULL(eq) == FALSE ).  ("eq" is a pointer to the event queue header.)
        !           182: *
        !           183: *   Before an event access session for a particular event, the macro users
        !           184: * must use the xxxBEGIN macro, and the xxxEND macro after an event is through
        !           185: * with.  As seen below, the xxxBEGIN and xxxEND macros maintain the event
        !           186: * queue access mechanism.
        !           187: *
        !           188: * First, the macros to be used by the event queue reader 
        !           189: */
        !           190: 
        !           191: #define ISEMPTY(eq)      ((eq)->header.head == (eq)->header.tail)
        !           192: #define GETBEGIN(eq)     (&(eq)->header.events[(eq)->header.head]) 
        !           193: 
        !           194: #define GET_X(event)     ((event)->vse_x)           /* get x position */
        !           195: #define GET_Y(event)     ((event)->vse_y)           /* get y position */
        !           196: #define GET_TIME(event)          ((event)->vse_time)        /* get time */
        !           197: #define GET_TYPE(event)          ((event)->vse_type)        /* get entry type */
        !           198: #define GET_KEY(event)   ((event)->vse_key)         /* get keycode */
        !           199: #define GET_DIR(event)   ((event)->vse_direction)     /* get direction */
        !           200: #define GET_DEVICE(event) ((event)->vse_device)        /* get device */
        !           201: 
        !           202: #define GETEND(eq)        (++(eq)->header.head >= (eq)->header.size ? \
        !           203:                           (eq)->header.head = 0 : 0 )
        !           204: 
        !           205: /*------------------------------------------------
        !           206: * macros to be used by the event queue loader  */
        !           207: 
        !           208:        /* ISFULL yields TRUE if queue is full */
        !           209: 
        !           210: #define ISFULL(eq)     ((eq)->header.tail+1 == (eq)->header.head ||   \
        !           211:                         ((eq)->header.tail+1 == (eq)->header.size &&  \
        !           212:                          (eq)->header.head == 0))
        !           213: 
        !           214:        /* get address of the billet for NEXT event */
        !           215: 
        !           216: #define PUTBEGIN(eq)   (&(eq)->header.events[(eq)->header.tail])
        !           217: 
        !           218: #define PUT_X(event, value)    ((event)->vse_x = value)    /* put X pos */
        !           219: #define PUT_Y(event, value)    ((event)->vse_y = value)    /* put Y pos */
        !           220: #define PUT_TIME(event, value) ((event)->vse_time = value)   /* put time */
        !           221: #define PUT_TYPE(event, value) ((event)->vse_type = value) /* put type */
        !           222: #define PUT_KEY(event, value)  ((event)->vse_key = value) /* put input key */
        !           223: #define PUT_DIR(event, value)  ((event)->vse_direction = value) /* put dir */
        !           224: #define PUT_DEVICE(event, value) ((event)->vse_device = value)   /* put dev */
        !           225: 
        !           226: #define PUTEND(eq)     (++(eq)->header.tail >= (eq)->header.size ?  \
        !           227:                        (eq)->header.tail = 0 : 0) 
        !           228: 
        !           229: /******************************************************************
        !           230: *
        !           231: *      DMA I/O DEFINITIONS
        !           232: *
        !           233: ******************************************************************/
        !           234: 
        !           235: /*---------------------------------------------------------------------
        !           236: * The DMA request queue is implemented as a ring buffer of "DMAreq"
        !           237:   structures.  The queue is accessed using ring indices located in the
        !           238:   "DMAreq_header" structure.  Access is implemented using access macros
        !           239:   similar to the event queue access macros above.  */
        !           240: 
        !           241:        struct DMAreq {
        !           242: 
        !           243:            short DMAtype;              /* DMA type code (for QDSS) */
        !           244:            short DMAdone;              /* DMA done parameter */
        !           245:            char  *bufp;                /* virtual adrs of buffer */
        !           246:            int   length;               /* transfer buffer length */
        !           247:        };
        !           248: 
        !           249: /* DMA type command codes */
        !           250: 
        !           251: #define DISPLIST       1       /* display list DMA */
        !           252: #define PTOB           2       /* 1 plane Qbus to bitmap DMA */
        !           253: #define BTOP           3       /* 1 plane bitmap to Qbus DMA */
        !           254: 
        !           255: /* DMA done notification code */
        !           256: 
        !           257: #define FIFO_EMPTY     0x01    /* DONE when FIFO becomes empty */
        !           258: #define COUNT_ZERO     0x02    /* DONE when count becomes zero */
        !           259: #define WORD_PACK      0x04    /* program the gate array for word packing */
        !           260: #define BYTE_PACK      0x08    /* program gate array for byte packing */
        !           261: #define REQUEST_DONE   0x100   /* clear when driver has processed request */
        !           262: #define HARD_ERROR     0x200   /* DMA hardware error occurred */
        !           263: 
        !           264: /* DMA request queue is a ring buffer of request structures */
        !           265: 
        !           266:        struct DMAreq_header {
        !           267: 
        !           268:            int QBAreg;             /* cookie Qbus map reg for this buffer */
        !           269:            short status;           /* master DMA status word */
        !           270:            int shared_size;        /* size of shared memory in bytes */
        !           271:            struct DMAreq *DMAreq;  /* start address of request queue */
        !           272:            int used;               /* # of queue entries currently used */
        !           273:            int size;               /* # of "DMAreq"'s in the request queue */
        !           274:            int oldest;             /* index to oldest queue'd request */
        !           275:            int newest;             /* index to newest queue'd request */
        !           276:        };
        !           277: 
        !           278: /* bit definitions for DMAstatus word in DMAreq_header */
        !           279: 
        !           280: #define        DMA_ACTIVE      0x0004          /* DMA in progress */
        !           281: #define DMA_ERROR      0x0080          /* DMA hardware error */
        !           282: #define DMA_IGNORE     0x0002          /* flag to ignore this interrupt */
        !           283: 
        !           284: /*------------------------------------------
        !           285: * macros for DMA request queue fiddling  */
        !           286: 
        !           287:        /* DMA status set/check macros */
        !           288: 
        !           289: #define DMA_SETACTIVE(header)   ((header)->status |= DMA_ACTIVE)
        !           290: #define DMA_CLRACTIVE(header)  ((header)->status &= ~DMA_ACTIVE)
        !           291: #define DMA_ISACTIVE(header)    ((header)->status & DMA_ACTIVE)
        !           292: 
        !           293: #define DMA_SETERROR(header)    ((header)->status |= DMA_ERROR)
        !           294: #define DMA_CLRERROR(header)    ((header)->status &= ~DMA_ERROR)
        !           295: #define DMA_ISERROR(header)     ((header)->status & DMA_ERROR)
        !           296: 
        !           297: #define DMA_SETIGNORE(header)  ((header)->status |= DMA_IGNORE)
        !           298: #define DMA_CLRIGNORE(header)   ((header)->status &= ~DMA_IGNORE)
        !           299: #define DMA_ISIGNORE(header)    ((header)->status & DMA_IGNORE)
        !           300: 
        !           301:        /* yields TRUE if queue is empty (ISEMPTY) or full (ISFULL) */
        !           302: 
        !           303: #define DMA_ISEMPTY(header)    ((header)->used == 0)
        !           304: #define DMA_ISFULL(header)     ((header)->used >= (header)->size)
        !           305: 
        !           306:        /* returns address of the billet for next (PUT)
        !           307:         * or oldest (GET) request */
        !           308: 
        !           309: #define DMA_PUTBEGIN(header)   (&(header)->DMAreq[(header)->newest])
        !           310: #define DMA_GETBEGIN(header)   (&(header)->DMAreq[(header)->oldest])
        !           311: 
        !           312:        /* does queue access pointer maintenance */
        !           313: 
        !           314: #define DMA_GETEND(header)      (++(header)->oldest >= (header)->size    \
        !           315:                                  ? (header)->oldest = 0 : 0);           \
        !           316:                                --(header)->used;
        !           317: 
        !           318: #define DMA_PUTEND(header)             (++(header)->newest >= (header)->size    \
        !           319:                                  ? (header)->newest = 0 : 0);           \
        !           320:                                ++(header)->used;
        !           321: 
        !           322: /******************************************************************
        !           323: *
        !           324: *      COLOR MAP WRITE BUFFER DEFINITIONS
        !           325: *
        !           326: ******************************************************************/
        !           327: 
        !           328:        struct rgb {
        !           329: 
        !           330:            unsigned char offset;       /* color map address for load */
        !           331:            unsigned char red;          /* data for red map */
        !           332:            unsigned char green;        /* data for green map */
        !           333:            unsigned char blue;         /* data for blue map */
        !           334:        };
        !           335: 
        !           336:        struct color_buf {
        !           337: 
        !           338:            char status;                /* load request/service status */
        !           339:            short count;                /* number of entries to br loaded */
        !           340:            struct rgb rgb[256];
        !           341:        };
        !           342: 
        !           343: #define LOAD_COLOR_MAP 0x0001
        !           344: 
        !           345: /******************************************************************
        !           346: *
        !           347: *      SCROLL ASSIST DEFINITIONS
        !           348: *
        !           349: ******************************************************************/
        !           350: 
        !           351:        struct scroll {
        !           352: 
        !           353:            short status;
        !           354:            short viper_constant;
        !           355:            short y_scroll_constant;
        !           356:            short y_offset;
        !           357:            short x_index_pending;
        !           358:            short y_index_pending;
        !           359:        };
        !           360: 
        !           361: #define LOAD_REGS      0x0001
        !           362: #define LOAD_INDEX     0x0002
        !           363: 
        !           364: /******************************************************************
        !           365: *
        !           366: *      MOUSE/TABLET/KBD PROGRAMMING DEFINITIONS
        !           367: *
        !           368: ******************************************************************/
        !           369: 
        !           370: /*-----------------------------------
        !           371: * LK201 programmming definitions  */
        !           372: 
        !           373: #define LK_UPDOWN      0x86            /* bits for setting lk201 modes */
        !           374: #define LK_AUTODOWN    0x82
        !           375: #define LK_DOWN        0x80
        !           376: #define LK_DEFAULTS    0xD3            /* reset (some) default settings */
        !           377: #define LK_AR_ENABLE   0xE3            /* global auto repeat enable */
        !           378: #define LK_CL_ENABLE   0x1B            /* keyclick enable */
        !           379: #define LK_KBD_ENABLE  0x8B            /* keyboard enable */
        !           380: #define LK_BELL_ENABLE         0x23            /* the bell */
        !           381: #define LK_RING_BELL   0xA7            /* ring keyboard bell */
        !           382: 
        !           383: #define LK_LED_ENABLE  0x13            /* light led */
        !           384: #define LK_LED_DISABLE         0x11            /* turn off led */
        !           385: #define LED_1          0x81            /* led bits */
        !           386: #define LED_2          0x82
        !           387: #define LED_3          0x84
        !           388: #define LED_4          0x88
        !           389: #define LED_ALL        0x8F
        !           390: #define LK_LED_HOLD    LED_4
        !           391: #define LK_LED_LOCK    LED_3
        !           392: #define LK_LED_COMPOSE LED_2
        !           393: #define LK_LED_WAIT    LED_1
        !           394: 
        !           395: #define LK_KDOWN_ERROR 0x3D            /* key down on powerup error */
        !           396: #define LK_POWER_ERROR         0x3E            /* keyboard failure on powerup test */
        !           397: #define LK_OUTPUT_ERROR        0xB5            /* keystrokes lost during inhibit */
        !           398: #define LK_INPUT_ERROR         0xB6            /* garbage command to keyboard */
        !           399: #define LK_LOWEST      0x56            /* lowest significant keycode */
        !           400: #define LK_DIV6_START  0xAD            /* start of div 6 */
        !           401: #define LK_DIV5_END    0xB2            /* end of div 5 */
        !           402: 
        !           403: #define LAST_PARAM     0x80            /* "no more params" bit */
        !           404: 
        !           405:        struct prgkbd {
        !           406: 
        !           407:            short cmd;                  /* LK201 command opcode */
        !           408:            short param1;               /* 1st cmd parameter (can be null) */
        !           409:            short param2;               /* 2nd cmd parameter (can be null) */
        !           410:        };
        !           411: 
        !           412: /*-------------------------
        !           413: * "special" LK-201 keys */
        !           414: 
        !           415: #define SHIFT          174
        !           416: #define LOCK           176
        !           417: #define REPEAT         180
        !           418: #define CNTRL          175
        !           419: #define ALLUP          179
        !           420: 
        !           421: /*--------------------------------
        !           422: * cursor programming structure */
        !           423: 
        !           424:        struct prg_cursor {
        !           425: 
        !           426:            unsigned short acc_factor;  /* cursor aceleration factor */
        !           427:            unsigned short threshold;   /* threshold to trigger acc at */
        !           428:        };
        !           429: 
        !           430: /*---------------------
        !           431: * mouse definitions */
        !           432: 
        !           433: #define INC_STREAM_MODE        'R'             /* stream mode reports (55 hz) */
        !           434: #define PROMPT_MODE    'D'             /* report when prompted */
        !           435: #define REQUEST_POS    'P'             /* request position report */
        !           436: #define SELF_TEST      'T'             /* request self test */
        !           437: 
        !           438: #define MOUSE_ID       0x2             /* mouse ID in lo 4 bits */
        !           439: 
        !           440: #define START_FRAME    0x80            /* start of report frame bit */
        !           441: #define X_SIGN         0x10            /* position sign bits */
        !           442: #define Y_SIGN         0x08
        !           443: 
        !           444: #define RIGHT_BUTTON   0x01            /* mouse buttons */
        !           445: #define MIDDLE_BUTTON  0x02
        !           446: #define LEFT_BUTTON    0x04
        !           447: 
        !           448:        /* mouse report structure definition */
        !           449: 
        !           450:        struct mouse_report {
        !           451: 
        !           452:            char state;         /* buttons and sign bits */
        !           453:            short dx;           /* delta X since last change */
        !           454:            short dy;           /* delta Y since last change */
        !           455:            char bytcnt;        /* mouse report byte count */
        !           456:        };
        !           457: 
        !           458: /*-----------------------------------------
        !           459: * tablet command/interface definitions  */
        !           460: 
        !           461: #define T_STREAM       'R'             /* continuous stream report mode */
        !           462: #define T_POINT                'D'             /* enter report-on-request mode */
        !           463: #define T_REQUEST      'P'             /* request position report */
        !           464: 
        !           465: #define T_BAUD         'B'             /* increase baud to 9600 from 4800 */
        !           466: #define T_RATE_55      'K'             /* report rate: 55/sec */
        !           467: #define T_RATE_72      'L'             /* report rate: 72/sec */
        !           468: #define T_RATE_120     'M'             /* report rate: 120/sec (9600 only) */
        !           469: 
        !           470: #define T_TEST         SELF_TEST       /* do self test */
        !           471: 
        !           472: #define TABLET_ID      0x4             /* tablet ID in lo 4 bits */
        !           473: 
        !           474: #define T_START_FRAME  0x80            /* start of report frame bit */
        !           475: #define T_PROXIMITY    0x01            /* state pointer in proximity */
        !           476: 
        !           477: #define T_LEFT_BUTTON  0x02            /* puck buttons */
        !           478: #define T_FRONT_BUTTON 0x04
        !           479: #define T_RIGHT_BUTTON 0x08
        !           480: #define T_BACK_BUTTON  0x10
        !           481: 
        !           482: #define T_BARREL_BUTTON T_LEFT_BUTTON          /* stylus buttons */
        !           483: #define T_TIP_BUTTON   T_FRONT_BUTTON
        !           484: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.