Replace ultra headers with version J

include/sys/u64driver.h

@@ -0,0 +1,131 @@
+#ifndef __SYS_U64DRIVER_H__
+#define __SYS_U64DRIVER_H__
+
+/*
+ * Copyright 1995, Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
+ * the contents of this file may not be disclosed to third parties, copied or
+ * duplicated in any form, in whole or in part, without the prior written
+ * permission of Silicon Graphics, Inc.
+ *
+ * RESTRICTED RIGHTS LEGEND:
+ * Use, duplication or disclosure by the Government is subject to restrictions
+ * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
+ * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
+ * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
+ * rights reserved under the Copyright Laws of the United States.
+ *
+ */
+
+#include <PR/rdb.h>
+#include <PR/ramrom.h>
+#include "u64gio.h"
+
+
+#if defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS)
+
+
+#define U64_MINOR_PRINT         1
+#define U64_MINOR_DEBUG         2
+#define U64_MINOR_LOGGING       3
+#define U64_MINOR_DATA		4
+#define U64_MINOR_FAULT         5
+#define U64_MINOR_KDEBUG        6
+#define U64_MINOR_PROFILE       7
+#define NUMBER_MINORS           8   /* don't use minor zero , but must count 0-7 */
+
+#define U64_MINOR_PRINT_BUF_SIZE         0x80000  /* buffer used by incoming printf data */
+#define U64_MINOR_DEBUG_BUF_SIZE         0x4000
+#define U64_MINOR_LOGGING_BUF_SIZE       RDB_LOG_MAX_BLOCK_SIZE  /* buffer used by incoming logging data */
+#define U64_MINOR_DATA_BUF_SIZE          RDB_DATA_MAX_BLOCK_SIZE  /* buffer used by incoming data */
+#define U64_MINOR_FAULT_BUF_SIZE         1024    /* buffer used for incoming fault data */
+#define U64_MINOR_KDEBUG_BUF_SIZE        1024    /* buffer used for incoming kdebug data */
+#define U64_MINOR_PROFILE_BUF_SIZE       2048    /* buffer used for incoming profile data */
+#define U64_MINOR_PROFILE_SEND_BUF_SIZE  16      /* only send one byte messages */
+#define U64_INTERNAL_WRITE_BUF_SIZE      0x8000  /* buffer used to store packets waiting to go out */
+
+
+
+#define u64_increment_Qptr(x)	{ ((x) = ((x) + 1) & 0xff) ; }
+
+
+typedef struct {
+    sema_t           minor_sema;     /* used to allow only one app to open the minor */
+    sema_t           read_sema;      /* used to block while waiting for data */
+    sema_t           write_sema;     /* only allow one entry to write at a time */
+    int              read_count;     /* the number of bytes waiting to be read */
+    int              write_count;    /* the number of bytes waiting to be written */
+    int              read_cur_write;
+    int              write_cur_write;
+    int              read_cur_read;
+    int              write_cur_read;
+    unsigned char    *read_buf;
+    unsigned char    *write_buf;
+    int              read_buf_size;  /* measured in unsigned char's */
+    int              write_buf_size;  /* measured in unsigned char's */
+    int              incoming_ct;    /* used by minors that receive data from game */
+                                     /* indicates how many bytes left in block  */
+                                     /* before signaling game that transfer is done */
+                                     /* used by logging and game to host data stuff */
+    int              message;        /* when not zero, send this message to game to */
+                                     /* indicate that data or log data has been read */
+    struct pollhead  *phead;
+} u64_minor;
+
+/*
+ * Our private one-per-board data structure
+ * The user can't get at any of this
+ */
+struct u64_data {
+
+    volatile struct u64_board	*board;
+    unsigned char		*memaddr;	/* 16/32 bit access R/W */
+
+    /*
+     * Only one client may be in the kernel at a time; this semaphore is used
+     * to prevent multiple clients from overrunning each other's interactions
+     * with the hardware.
+     */
+    sema_t			ioctl_sema;
+
+    /*
+     * The ramrom_sema is used by the driver so that it can arbitrate for the
+     * control of ramrom with the game, and sleep while waiting for the game
+     * to respond.
+     */
+    sema_t			ramrom_sema;
+
+    /*
+     * Allocate a megabyte buffer which we can use when reading/writing data
+     * to or from the board (we can't copyin/copyout directly from the user's
+     * buffer, because those routines use 64 bit transfers).
+     */
+    unsigned int		*oneMeg;
+
+    union {
+	u64_write_arg_t u64_write;	/* WRITE, SAFE_WRITE */
+	u64_read_arg_t u64_read;	/* READ, SAFE_READ */
+    }                           args;
+
+    /* rdb port */
+    unsigned int                *write_buf;
+    unsigned int                write_buf_cur_write;
+    unsigned int                write_buf_cur_read;
+    unsigned int                write_buf_ct;    /* number of packets waiting for transmission */
+    unsigned int                write_buf_size;  /* measured in rdbPackets */
+    sema_t                      write_buf_sema;
+    u64_minor                   minors[NUMBER_MINORS];
+
+};
+
+#endif /* defined(_LANGUAGE_C) || defined(_LANGUAGE_C_PLUS_PLUS) */
+
+#endif /* __SYS_U64DRIVER_H__ */
+
+
+
+
+
+