Debian Codegraph @

tools/testing/selftests/powerpc/nx-gzip/include/nxu.h

raw
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * Hardware interface of the NX-GZIP compression accelerator
4 *
5 * Copyright (C) IBM Corporation, 2020
6 *
7 * Author: Bulent Abali <[email protected]>
8 *
9 */
10
11 #ifndef _NXU_H
12 #define _NXU_H
13
14 #include <stdint.h>
15 #include <endian.h>
16 #include "nx.h"
17
18 /* deflate */
19 #define LLSZ 286
20 #define DSZ 30
21
22 /* nx */
23 #define DHTSZ 18
24 #define DHT_MAXSZ 288
25 #define MAX_DDE_COUNT 256
26
27 /* util */
28 #ifdef NXDBG
29 #define NXPRT(X) X
30 #else
31 #define NXPRT(X)
32 #endif
33
34 #ifdef NXTIMER
35 #include <sys/platform/ppc.h>
36 #define NX_CLK(X) X
37 #define nx_get_time() __ppc_get_timebase()
38 #define nx_get_freq() __ppc_get_timebase_freq()
39 #else
40 #define NX_CLK(X)
41 #define nx_get_time() (-1)
42 #define nx_get_freq() (-1)
43 #endif
44
45 #define NX_MAX_FAULTS 500
46
47 /*
48 * Definitions of acronyms used here. See
49 * P9 NX Gzip Accelerator User's Manual for details:
50 * https://github.com/libnxz/power-gzip/blob/develop/doc/power_nx_gzip_um.pdf
51 *
52 * adler/crc: 32 bit checksums appended to stream tail
53 * ce: completion extension
54 * cpb: coprocessor parameter block (metadata)
55 * crb: coprocessor request block (command)
56 * csb: coprocessor status block (status)
57 * dht: dynamic huffman table
58 * dde: data descriptor element (address, length)
59 * ddl: list of ddes
60 * dh/fh: dynamic and fixed huffman types
61 * fc: coprocessor function code
62 * histlen: history/dictionary length
63 * history: sliding window of up to 32KB of data
64 * lzcount: Deflate LZ symbol counts
65 * rembytecnt: remaining byte count
66 * sfbt: source final block type; last block's type during decomp
67 * spbc: source processed byte count
68 * subc: source unprocessed bit count
69 * tebc: target ending bit count; valid bits in the last byte
70 * tpbc: target processed byte count
71 * vas: virtual accelerator switch; the user mode interface
72 */
73
74 union nx_qw_t {
75 uint32_t word[4];
76 uint64_t dword[2];
77 } __aligned(16);
78
79 /*
80 * Note: NX registers with fewer than 32 bits are declared by
81 * convention as uint32_t variables in unions. If *_offset and *_mask
82 * are defined for a variable, then use get_ put_ macros to
83 * conveniently access the register fields for endian conversions.
84 */
85
86 struct nx_dde_t {
87 /* Data Descriptor Element, Section 6.4 */
88 union {
89 uint32_t dde_count;
90 /* When dde_count == 0 ddead is a pointer to a data buffer;
91 * ddebc is the buffer length bytes.
92 * When dde_count > 0 dde is an indirect dde; ddead is a
93 * pointer to a contiguous list of direct ddes; ddebc is the
94 * total length of all data pointed to by the list of direct
95 * ddes. Note that only one level of indirection is permitted.
96 * See Section 6.4 of the user manual for additional details.
97 */
98 };
99 uint32_t ddebc; /* dde byte count */
100 uint64_t ddead; /* dde address */
101 } __aligned(16);
102
103 struct nx_csb_t {
104 /* Coprocessor Status Block, Section 6.6 */
105 union {
106 uint32_t csb_v;
107 /* Valid bit. v must be set to 0 by the program
108 * before submitting the coprocessor command.
109 * Software can poll for the v bit
110 */
111
112 uint32_t csb_f;
113 /* 16B CSB size. Written to 0 by DMA when it writes the CPB */
114
115 uint32_t csb_cs;
116 /* cs completion sequence; unused */
117
118 uint32_t csb_cc;
119 /* cc completion code; cc != 0 exception occurred */
120
121 uint32_t csb_ce;
122 /* ce completion extension */
123
124 };
125 uint32_t tpbc;
126 /* target processed byte count TPBC */
127
128 uint64_t fsaddr;
129 /* Section 6.12.1 CSB NonZero error summary. FSA Failing storage
130 * address. Address where error occurred. When available, written
131 * to A field of CSB
132 */
133 } __aligned(16);
134
135 struct nx_ccb_t {
136 /* Coprocessor Completion Block, Section 6.7 */
137
138 uint32_t reserved[3];
139 union {
140 /* When crb.c==0 (no ccb defined) it is reserved;
141 * When crb.c==1 (ccb defined) it is cm
142 */
143
144 uint32_t ccb_cm;
145 /* Signal interrupt of crb.c==1 and cm==1 */
146
147 uint32_t word;
148 /* generic access to the 32bit word */
149 };
150 } __aligned(16);
151
152 struct vas_stamped_crb_t {
153 /*
154 * CRB operand of the paste coprocessor instruction is stamped
155 * in quadword 4 with the information shown here as its written
156 * in to the receive FIFO of the coprocessor
157 */
158
159 union {
160 uint32_t vas_buf_num;
161 /* Verification only vas buffer number which correlates to
162 * the low order bits of the atag in the paste command
163 */
164
165 uint32_t send_wc_id;
166 /* Pointer to Send Window Context that provides for NX address
167 * translation information, such as MSR and LPCR bits, job
168 * completion interrupt RA, PSWID, and job utilization counter.
169 */
170
171 };
172 union {
173 uint32_t recv_wc_id;
174 /* Pointer to Receive Window Context. NX uses this to return
175 * credits to a Receive FIFO as entries are dequeued.
176 */
177
178 };
179 uint32_t reserved2;
180 union {
181 uint32_t vas_invalid;
182 /* Invalid bit. If this bit is 1 the CRB is discarded by
183 * NX upon fetching from the receive FIFO. If this bit is 0
184 * the CRB is processed normally. The bit is stamped to 0
185 * by VAS and may be written to 1 by hypervisor while
186 * the CRB is in the receive FIFO (in memory).
187 */
188
189 };
190 };
191
192 struct nx_stamped_fault_crb_t {
193 /*
194 * A CRB that has a translation fault is stamped by NX in quadword 4
195 * and pasted to the Fault Send Window in VAS.
196 */
197 uint64_t fsa;
198 union {
199 uint32_t nxsf_t;
200 uint32_t nxsf_fs;
201 };
202 uint32_t pswid;
203 };
204
205 union stamped_crb_t {
206 struct vas_stamped_crb_t vas;
207 struct nx_stamped_fault_crb_t nx;
208 };
209
210 struct nx_gzip_cpb_t {
211 /*
212 * Coprocessor Parameter Block In/Out are used to pass metadata
213 * to/from accelerator. Tables 6.5 and 6.6 of the user manual.
214 */
215
216 /* CPBInput */
217
218 struct {
219 union {
220 union nx_qw_t qw0;
221 struct {
222 uint32_t in_adler; /* bits 0:31 */
223 uint32_t in_crc; /* bits 32:63 */
224 union {
225 uint32_t in_histlen; /* bits 64:75 */
226 uint32_t in_subc; /* bits 93:95 */
227 };
228 union {
229 /* bits 108:111 */
230 uint32_t in_sfbt;
231 /* bits 112:127 */
232 uint32_t in_rembytecnt;
233 /* bits 116:127 */
234 uint32_t in_dhtlen;
235 };
236 };
237 };
238 union {
239 union nx_qw_t in_dht[DHTSZ]; /* qw[1:18] */
240 char in_dht_char[DHT_MAXSZ]; /* byte access */
241 };
242 union nx_qw_t reserved[5]; /* qw[19:23] */
243 };
244
245 /* CPBOutput */
246
247 volatile struct {
248 union {
249 union nx_qw_t qw24;
250 struct {
251 uint32_t out_adler; /* bits 0:31 qw[24] */
252 uint32_t out_crc; /* bits 32:63 qw[24] */
253 union {
254 /* bits 77:79 qw[24] */
255 uint32_t out_tebc;
256 /* bits 80:95 qw[24] */
257 uint32_t out_subc;
258 };
259 union {
260 /* bits 108:111 qw[24] */
261 uint32_t out_sfbt;
262 /* bits 112:127 qw[24] */
263 uint32_t out_rembytecnt;
264 /* bits 116:127 qw[24] */
265 uint32_t out_dhtlen;
266 };
267 };
268 };
269 union {
270 union nx_qw_t qw25[79]; /* qw[25:103] */
271 /* qw[25] compress no lzcounts or wrap */
272 uint32_t out_spbc_comp_wrap;
273 uint32_t out_spbc_wrap; /* qw[25] wrap */
274 /* qw[25] compress no lzcounts */
275 uint32_t out_spbc_comp;
276 /* 286 LL and 30 D symbol counts */
277 uint32_t out_lzcount[LLSZ+DSZ];
278 struct {
279 union nx_qw_t out_dht[DHTSZ]; /* qw[25:42] */
280 /* qw[43] decompress */
281 uint32_t out_spbc_decomp;
282 };
283 };
284 /* qw[104] compress with lzcounts */
285 uint32_t out_spbc_comp_with_count;
286 };
287 } __aligned(128);
288
289 struct nx_gzip_crb_t {
290 union { /* byte[0:3] */
291 uint32_t gzip_fc; /* bits[24-31] */
292 };
293 uint32_t reserved1; /* byte[4:7] */
294 union {
295 uint64_t csb_address; /* byte[8:15] */
296 struct {
297 uint32_t reserved2;
298 union {
299 uint32_t crb_c;
300 /* c==0 no ccb defined */
301
302 uint32_t crb_at;
303 /* at==0 address type is ignored;
304 * all addrs effective assumed.
305 */
306
307 };
308 };
309 };
310 struct nx_dde_t source_dde; /* byte[16:31] */
311 struct nx_dde_t target_dde; /* byte[32:47] */
312 volatile struct nx_ccb_t ccb; /* byte[48:63] */
313 volatile union {
314 /* byte[64:239] shift csb by 128 bytes out of the crb; csb was
315 * in crb earlier; JReilly says csb written with partial inject
316 */
317 union nx_qw_t reserved64[11];
318 union stamped_crb_t stamp; /* byte[64:79] */
319 };
320 volatile struct nx_csb_t csb;
321 } __aligned(128);
322
323 struct nx_gzip_crb_cpb_t {
324 struct nx_gzip_crb_t crb;
325 struct nx_gzip_cpb_t cpb;
326 } __aligned(2048);
327
328
329 /*
330 * NX hardware convention has the msb bit on the left numbered 0.
331 * The defines below has *_offset defined as the right most bit
332 * position of a field. x of size_mask(x) is the field width in bits.
333 */
334
335 #define size_mask(x) ((1U<<(x))-1)
336
337 /*
338 * Offsets and Widths within the containing 32 bits of the various NX
339 * gzip hardware registers. Use the getnn/putnn macros to access
340 * these regs
341 */
342
343 #define dde_count_mask size_mask(8)
344 #define dde_count_offset 23
345
346 /* CSB */
347
348 #define csb_v_mask size_mask(1)
349 #define csb_v_offset 0
350 #define csb_f_mask size_mask(1)
351 #define csb_f_offset 6
352 #define csb_cs_mask size_mask(8)
353 #define csb_cs_offset 15
354 #define csb_cc_mask size_mask(8)
355 #define csb_cc_offset 23
356 #define csb_ce_mask size_mask(8)
357 #define csb_ce_offset 31
358
359 /* CCB */
360
361 #define ccb_cm_mask size_mask(3)
362 #define ccb_cm_offset 31
363
364 /* VAS stamped CRB fields */
365
366 #define vas_buf_num_mask size_mask(6)
367 #define vas_buf_num_offset 5
368 #define send_wc_id_mask size_mask(16)
369 #define send_wc_id_offset 31
370 #define recv_wc_id_mask size_mask(16)
371 #define recv_wc_id_offset 31
372 #define vas_invalid_mask size_mask(1)
373 #define vas_invalid_offset 31
374
375 /* NX stamped fault CRB fields */
376
377 #define nxsf_t_mask size_mask(1)
378 #define nxsf_t_offset 23
379 #define nxsf_fs_mask size_mask(8)
380 #define nxsf_fs_offset 31
381
382 /* CPB input */
383
384 #define in_histlen_mask size_mask(12)
385 #define in_histlen_offset 11
386 #define in_dhtlen_mask size_mask(12)
387 #define in_dhtlen_offset 31
388 #define in_subc_mask size_mask(3)
389 #define in_subc_offset 31
390 #define in_sfbt_mask size_mask(4)
391 #define in_sfbt_offset 15
392 #define in_rembytecnt_mask size_mask(16)
393 #define in_rembytecnt_offset 31
394
395 /* CPB output */
396
397 #define out_tebc_mask size_mask(3)
398 #define out_tebc_offset 15
399 #define out_subc_mask size_mask(16)
400 #define out_subc_offset 31
401 #define out_sfbt_mask size_mask(4)
402 #define out_sfbt_offset 15
403 #define out_rembytecnt_mask size_mask(16)
404 #define out_rembytecnt_offset 31
405 #define out_dhtlen_mask size_mask(12)
406 #define out_dhtlen_offset 31
407
408 /* CRB */
409
410 #define gzip_fc_mask size_mask(8)
411 #define gzip_fc_offset 31
412 #define crb_c_mask size_mask(1)
413 #define crb_c_offset 28
414 #define crb_at_mask size_mask(1)
415 #define crb_at_offset 30
416 #define csb_address_mask ~(15UL) /* mask off bottom 4b */
417
418 /*
419 * Access macros for the registers. Do not access registers directly
420 * because of the endian conversion. P9 processor may run either as
421 * Little or Big endian. However the NX coprocessor regs are always
422 * big endian.
423 * Use the 32 and 64b macros to access respective
424 * register sizes.
425 * Use nn forms for the register fields shorter than 32 bits.
426 */
427
428 #define getnn(ST, REG) ((be32toh(ST.REG) >> (31-REG##_offset)) \
429 & REG##_mask)
430 #define getpnn(ST, REG) ((be32toh((ST)->REG) >> (31-REG##_offset)) \
431 & REG##_mask)
432 #define get32(ST, REG) (be32toh(ST.REG))
433 #define getp32(ST, REG) (be32toh((ST)->REG))
434 #define get64(ST, REG) (be64toh(ST.REG))
435 #define getp64(ST, REG) (be64toh((ST)->REG))
436
437 #define unget32(ST, REG) (get32(ST, REG) & ~((REG##_mask) \
438 << (31-REG##_offset)))
439 /* get 32bits less the REG field */
440
441 #define ungetp32(ST, REG) (getp32(ST, REG) & ~((REG##_mask) \
442 << (31-REG##_offset)))
443 /* get 32bits less the REG field */
444
445 #define clear_regs(ST) memset((void *)(&(ST)), 0, sizeof(ST))
446 #define clear_dde(ST) do { ST.dde_count = ST.ddebc = 0; ST.ddead = 0; \
447 } while (0)
448 #define clearp_dde(ST) do { (ST)->dde_count = (ST)->ddebc = 0; \
449 (ST)->ddead = 0; \
450 } while (0)
451 #define clear_struct(ST) memset((void *)(&(ST)), 0, sizeof(ST))
452 #define putnn(ST, REG, X) (ST.REG = htobe32(unget32(ST, REG) | (((X) \
453 & REG##_mask) << (31-REG##_offset))))
454 #define putpnn(ST, REG, X) ((ST)->REG = htobe32(ungetp32(ST, REG) \
455 | (((X) & REG##_mask) << (31-REG##_offset))))
456
457 #define put32(ST, REG, X) (ST.REG = htobe32(X))
458 #define putp32(ST, REG, X) ((ST)->REG = htobe32(X))
459 #define put64(ST, REG, X) (ST.REG = htobe64(X))
460 #define putp64(ST, REG, X) ((ST)->REG = htobe64(X))
461
462 /*
463 * Completion extension ce(0) ce(1) ce(2). Bits ce(3-7)
464 * unused. Section 6.6 Figure 6.7.
465 */
466
467 #define get_csb_ce(ST) ((uint32_t)getnn(ST, csb_ce))
468 #define get_csb_ce_ms3b(ST) (get_csb_ce(ST) >> 5)
469 #define put_csb_ce_ms3b(ST, X) putnn(ST, csb_ce, ((uint32_t)(X) << 5))
470
471 #define CSB_CE_PARTIAL 0x4
472 #define CSB_CE_TERMINATE 0x2
473 #define CSB_CE_TPBC_VALID 0x1
474
475 #define csb_ce_termination(X) (!!((X) & CSB_CE_TERMINATE))
476 /* termination, output buffers may be modified, SPBC/TPBC invalid Fig.6-7 */
477
478 #define csb_ce_check_completion(X) (!csb_ce_termination(X))
479 /* if not terminated then check full or partial completion */
480
481 #define csb_ce_partial_completion(X) (!!((X) & CSB_CE_PARTIAL))
482 #define csb_ce_full_completion(X) (!csb_ce_partial_completion(X))
483 #define csb_ce_tpbc_valid(X) (!!((X) & CSB_CE_TPBC_VALID))
484 /* TPBC indicates successfully stored data count */
485
486 #define csb_ce_default_err(X) csb_ce_termination(X)
487 /* most error CEs have CE(0)=0 and CE(1)=1 */
488
489 #define csb_ce_cc3_partial(X) csb_ce_partial_completion(X)
490 /* some CC=3 are partially completed, Table 6-8 */
491
492 #define csb_ce_cc64(X) ((X)&(CSB_CE_PARTIAL \
493 | CSB_CE_TERMINATE) == 0)
494 /* Compression: when TPBC>SPBC then CC=64 Table 6-8; target didn't
495 * compress smaller than source.
496 */
497
498 /* Decompress SFBT combinations Tables 5-3, 6-4, 6-6 */
499
500 #define SFBT_BFINAL 0x1
501 #define SFBT_LIT 0x4
502 #define SFBT_FHT 0x5
503 #define SFBT_DHT 0x6
504 #define SFBT_HDR 0x7
505
506 /*
507 * NX gzip function codes. Table 6.2.
508 * Bits 0:4 are the FC. Bit 5 is used by the DMA controller to
509 * select one of the two Byte Count Limits.
510 */
511
512 #define GZIP_FC_LIMIT_MASK 0x01
513 #define GZIP_FC_COMPRESS_FHT 0x00
514 #define GZIP_FC_COMPRESS_DHT 0x02
515 #define GZIP_FC_COMPRESS_FHT_COUNT 0x04
516 #define GZIP_FC_COMPRESS_DHT_COUNT 0x06
517 #define GZIP_FC_COMPRESS_RESUME_FHT 0x08
518 #define GZIP_FC_COMPRESS_RESUME_DHT 0x0a
519 #define GZIP_FC_COMPRESS_RESUME_FHT_COUNT 0x0c
520 #define GZIP_FC_COMPRESS_RESUME_DHT_COUNT 0x0e
521 #define GZIP_FC_DECOMPRESS 0x10
522 #define GZIP_FC_DECOMPRESS_SINGLE_BLK_N_SUSPEND 0x12
523 #define GZIP_FC_DECOMPRESS_RESUME 0x14
524 #define GZIP_FC_DECOMPRESS_RESUME_SINGLE_BLK_N_SUSPEND 0x16
525 #define GZIP_FC_WRAP 0x1e
526
527 #define fc_is_compress(fc) (((fc) & 0x10) == 0)
528 #define fc_has_count(fc) (fc_is_compress(fc) && (((fc) & 0x4) != 0))
529
530 /* CSB.CC Error codes */
531
532 #define ERR_NX_OK 0
533 #define ERR_NX_ALIGNMENT 1
534 #define ERR_NX_OPOVERLAP 2
535 #define ERR_NX_DATA_LENGTH 3
536 #define ERR_NX_TRANSLATION 5
537 #define ERR_NX_PROTECTION 6
538 #define ERR_NX_EXTERNAL_UE7 7
539 #define ERR_NX_INVALID_OP 8
540 #define ERR_NX_PRIVILEGE 9
541 #define ERR_NX_INTERNAL_UE 10
542 #define ERR_NX_EXTERN_UE_WR 12
543 #define ERR_NX_TARGET_SPACE 13
544 #define ERR_NX_EXCESSIVE_DDE 14
545 #define ERR_NX_TRANSL_WR 15
546 #define ERR_NX_PROTECT_WR 16
547 #define ERR_NX_SUBFUNCTION 17
548 #define ERR_NX_FUNC_ABORT 18
549 #define ERR_NX_BYTE_MAX 19
550 #define ERR_NX_CORRUPT_CRB 20
551 #define ERR_NX_INVALID_CRB 21
552 #define ERR_NX_INVALID_DDE 30
553 #define ERR_NX_SEGMENTED_DDL 31
554 #define ERR_NX_DDE_OVERFLOW 33
555 #define ERR_NX_TPBC_GT_SPBC 64
556 #define ERR_NX_MISSING_CODE 66
557 #define ERR_NX_INVALID_DIST 67
558 #define ERR_NX_INVALID_DHT 68
559 #define ERR_NX_EXTERNAL_UE90 90
560 #define ERR_NX_WDOG_TIMER 224
561 #define ERR_NX_AT_FAULT 250
562 #define ERR_NX_INTR_SERVER 252
563 #define ERR_NX_UE253 253
564 #define ERR_NX_NO_HW 254
565 #define ERR_NX_HUNG_OP 255
566 #define ERR_NX_END 256
567
568 /* initial values for non-resume operations */
569 #define INIT_CRC 0 /* crc32(0L, Z_NULL, 0) */
570 #define INIT_ADLER 1 /* adler32(0L, Z_NULL, 0) adler is initialized to 1 */
571
572 /* prototypes */
573 int nxu_submit_job(struct nx_gzip_crb_cpb_t *c, void *handle);
574
575 extern void nxu_sigsegv_handler(int sig, siginfo_t *info, void *ctx);
576 extern int nxu_touch_pages(void *buf, long buf_len, long page_len, int wr);
577
578 /* caller supplies a print buffer 4*sizeof(crb) */
579
580 char *nx_crb_str(struct nx_gzip_crb_t *crb, char *prbuf);
581 char *nx_cpb_str(struct nx_gzip_cpb_t *cpb, char *prbuf);
582 char *nx_prt_hex(void *cp, int sz, char *prbuf);
583 char *nx_lzcount_str(struct nx_gzip_cpb_t *cpb, char *prbuf);
584 char *nx_strerror(int e);
585
586 #ifdef NX_SIM
587 #include <stdio.h>
588 int nx_sim_init(void *ctx);
589 int nx_sim_end(void *ctx);
590 int nxu_run_sim_job(struct nx_gzip_crb_cpb_t *c, void *ctx);
591 #endif /* NX_SIM */
592
593 /* Deflate stream manipulation */
594
595 #define set_final_bit(x) (x |= (unsigned char)1)
596 #define clr_final_bit(x) (x &= ~(unsigned char)1)
597
598 #define append_empty_fh_blk(p, b) do { *(p) = (2 | (1&(b))); *((p)+1) = 0; \
599 } while (0)
600 /* append 10 bits 0000001b 00...... ;
601 * assumes appending starts on a byte boundary; b is the final bit.
602 */
603
604
605 #ifdef NX_842
606
607 /* 842 Engine */
608
609 struct nx_eft_crb_t {
610 union { /* byte[0:3] */
611 uint32_t eft_fc; /* bits[29-31] */
612 };
613 uint32_t reserved1; /* byte[4:7] */
614 union {
615 uint64_t csb_address; /* byte[8:15] */
616 struct {
617 uint32_t reserved2;
618 union {
619 uint32_t crb_c;
620 /* c==0 no ccb defined */
621
622 uint32_t crb_at;
623 /* at==0 address type is ignored;
624 * all addrs effective assumed.
625 */
626
627 };
628 };
629 };
630 struct nx_dde_t source_dde; /* byte[16:31] */
631 struct nx_dde_t target_dde; /* byte[32:47] */
632 struct nx_ccb_t ccb; /* byte[48:63] */
633 union {
634 union nx_qw_t reserved64[3]; /* byte[64:96] */
635 };
636 struct nx_csb_t csb;
637 } __aligned(128);
638
639 /* 842 CRB */
640
641 #define EFT_FC_MASK size_mask(3)
642 #define EFT_FC_OFFSET 31
643 #define EFT_FC_COMPRESS 0x0
644 #define EFT_FC_COMPRESS_WITH_CRC 0x1
645 #define EFT_FC_DECOMPRESS 0x2
646 #define EFT_FC_DECOMPRESS_WITH_CRC 0x3
647 #define EFT_FC_BLK_DATA_MOVE 0x4
648 #endif /* NX_842 */
649
650 #endif /* _NXU_H */