/*	$NetBSD: eshconfig.c,v 1.10 2011/08/30 18:28:59 joerg Exp $	*/

/*
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code contributed to The NetBSD Foundation by Kevin M. Lahey
 * of the Numerical Aerospace Simulation Facility, NASA Ames Research 
 * Center.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: eshconfig.c,v 1.10 2011/08/30 18:28:59 joerg Exp $");
#endif /* not lint */

#include <sys/param.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/sockio.h>
#include <fcntl.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <dev/ic/rrunnerreg.h>
#include <dev/ic/rrunnervar.h>

/*
 * Create a simple pair of tables to map possible burst DMA values
 * to the values required by the RoadRunner.
 */

struct map_dma {
	int       value;
	u_int32_t rr_value;
};

static struct map_dma read_dma_map[] =  {{0,    RR_PS_READ_DISABLE},
				  {4,    RR_PS_READ_4},
				  {16,   RR_PS_READ_16},
				  {32,   RR_PS_READ_32},
				  {64,   RR_PS_READ_64},
				  {128,  RR_PS_READ_128},
				  {256,  RR_PS_READ_256},
				  {1024, RR_PS_READ_1024},
				  {-1,    0}};

static struct map_dma write_dma_map[] = {{0,    RR_PS_WRITE_DISABLE},
				  {4,    RR_PS_WRITE_4},
				  {16,   RR_PS_WRITE_16},
				  {32,   RR_PS_WRITE_32},
				  {64,   RR_PS_WRITE_64},
				  {128,  RR_PS_WRITE_128},
				  {256,  RR_PS_WRITE_256},
				  {1024, RR_PS_WRITE_1024},
				  {-1,   0}};

/*
 * The RunCode is composed of separate segments, each of which has a
 * starting address in SRAM memory (for running) and in EEPROM
 * (for storage).
 */


struct rr_seg_descr {
	u_int32_t	start_addr;
	u_int32_t	length;
	u_int32_t	ee_addr;
};

static u_int32_t	do_map(int, struct map_dma *);
static void 		eeprom_upload(const char *);
static void 		eeprom_download(const char *);
static u_int32_t 	rr_checksum(const u_int32_t *, int);
static void 		esh_tune(void);
static void 		esh_tune_eeprom(void);
static void 		esh_tuning_stats(void);
static void 		esh_stats(int);
static void 		esh_reset(void);
static int 		drvspec_ioctl(char *, int, int, int, caddr_t);
__dead static void		usage(void);

static char name[30] = "esh0";
static int s;

#define RR_EE_SIZE 8192
static u_int32_t eeprom[RR_EE_SIZE];
static u_int32_t runcode[RR_EE_SIZE];

static struct ifdrv ifd;

/* drvspec_ioctl
 * 
 * We defined a driver-specific socket ioctl to allow us to tweak
 * the characteristics of network devices.  This routine will
 * provide a shortcut to calling this routine, which would otherwise
 * require lots of costly and annoying setup.
 */

static int
drvspec_ioctl(char *lname, int fd, int cmd, int len, caddr_t data)
{
	strcpy(ifd.ifd_name, lname);
	ifd.ifd_cmd = cmd;
	ifd.ifd_len = len;
	ifd.ifd_data = data;
    
	return ioctl(fd, SIOCSDRVSPEC, (caddr_t) &ifd);
}

static void
usage(void)
{
	fprintf(stderr, "eshconfig -- configure Essential Communications "
		"HIPPI driver\n");
	fprintf(stderr, "-b burst size for read\n");
	fprintf(stderr, "-c burst size for write:\n");
	fprintf(stderr, "\t0 (no limit), 5, 16, 32, 64, 128, 256, 1024\n");
	fprintf(stderr, "-d download filename\n");
	fprintf(stderr, "-e write data to EEPROM\n");
	fprintf(stderr, "-m minimum bytes DMA per direction\n");
	fprintf(stderr, "-r bytes before DMA starts for read\n");
	fprintf(stderr, "-s show statistics (-ss to display only non-zero)\n");
	fprintf(stderr, "-t show tuning parameters\n");
	fprintf(stderr, "-u upload filename [not working]\n");
	fprintf(stderr, "-w bytes before DMA starts for write\n");
	fprintf(stderr, "-i interrupt delay in usecs\n");
	fprintf(stderr, "-x reset interface\n");
	exit(1);
}

/* do_map
 *
 * Map between values for burst DMA sizes and the values expected by
 * the RoadRunner chip.
 */

static u_int32_t
do_map(int value, struct map_dma *map)
{
	int i;

	for (i = 0; map[i].value != -1; i++)
		if (value == map[i].value)
			return map[i].rr_value;

	return -1;
}

/* do_map_dma
 *
 * Reverse the mapping.
 */
 
static int
do_map_dma(uint32_t value, struct map_dma *map)
{
	int i;

	for (i = 0; map[i].value != -1; i++)
		if (value == map[i].rr_value)
			return map[i].value;

	return 0;
}


static int dma_thresh_read = -1;
static int dma_thresh_write = -1;
static int dma_min_grab = -1;
static int dma_max_read = -1;
static int dma_max_write = -1;

static int interrupt_delay = -1;

static int get_stats = 0;
static int get_tuning_stats = 0;
static int eeprom_write = 0;
static char *eeprom_download_filename = NULL;
static char *eeprom_upload_filename = NULL;
static int reset = 0;

static struct rr_tuning rr_tune;
struct rr_eeprom rr_eeprom;
struct rr_stats rr_stats;

int
main(int argc, char *argv[])
{
	int ch;

	/* Parse command-line options */

	while ((ch = getopt(argc, argv, "b:c:d:ei:m:r:stu:w:x")) != -1) {
		switch (ch) {
		case 'b':
			dma_max_read = atoi(optarg);
			break;
		case 'c':
			dma_max_write = atoi(optarg);
			break;
		case 'd':
			eeprom_download_filename = optarg;
			break;
		case 'e':
			eeprom_write++;
			break;
		case 'i':
			interrupt_delay = atoi(optarg);
			break;
		case 'm':
			dma_min_grab = atoi(optarg);
			break;
		case 'r':
			dma_thresh_read = atoi(optarg);
			break;
		case 's':
			get_stats++;
			break;
		case 't':
			get_tuning_stats++;
			break;
		case 'u':
			eeprom_upload_filename = optarg;
			break;
		case 'w':
			dma_thresh_write = atoi(optarg);
			break;
		case 'x':
			reset = 1;
			break;
		default:
			usage();
			/* NOTREACHED */
		}
	}
	argc -= optind;
	argv += optind;

	if (argc > 1)
		usage();
	if (argc == 1) {
		(void) strncpy(name, argv[0], sizeof(name));
		argc--; argv++;
	}

	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0)
		err(1, "socket");

	if (eeprom_upload_filename)
		eeprom_upload(eeprom_upload_filename);

	if (eeprom_download_filename)
		eeprom_download(eeprom_download_filename);

	if (get_stats) {
		esh_stats(get_stats);
	}

    	if (drvspec_ioctl(name, s, EIOCGTUNE, sizeof(struct rr_tuning),
			  (caddr_t) &rr_tune) < 0) {
		err(1, "ioctl(EIOCGTUNE)");
	}

	if (get_tuning_stats) {
		if (get_stats)
			printf("\n");
		esh_tuning_stats();
	}

	if (eeprom_write || dma_thresh_read != -1 || 
	    dma_thresh_write != -1 ||
	    dma_min_grab != -1 ||
	    dma_max_read != -1 ||
	    dma_max_write != -1 ||
	    interrupt_delay != -1) {
		esh_tune();
	}

	if (eeprom_write)
		esh_tune_eeprom();

	if (reset)
		esh_reset();

	exit(0);
}

static void
esh_tune(void)
{
	dma_max_read = do_map(dma_max_read, read_dma_map);
	if (dma_max_read != -1) {
		rr_tune.rt_pci_state &= ~RR_PS_READ_MASK;
		rr_tune.rt_pci_state |= dma_max_read;
	}

	dma_max_write = do_map(dma_max_write, write_dma_map);
	if (dma_max_write != -1) {
		rr_tune.rt_pci_state &= ~RR_PS_WRITE_MASK;
		rr_tune.rt_pci_state |= dma_max_write;
	}

	if (dma_min_grab != -1) {
		if ((dma_min_grab & (RR_PS_MIN_DMA_MASK >> RR_PS_MIN_DMA_SHIFT))
		    != dma_min_grab)
			usage();
		rr_tune.rt_pci_state &= ~RR_PS_MIN_DMA_MASK;
		rr_tune.rt_pci_state |= 
			(dma_min_grab << RR_PS_MIN_DMA_SHIFT);
	}

	if (dma_thresh_write != -1) {
		if (dma_thresh_write < 1 || dma_thresh_write > RR_DW_THRESHOLD_MAX)
			usage();
		rr_tune.rt_dma_write_state &= ~RR_DW_THRESHOLD_MASK;
		rr_tune.rt_dma_write_state |= 
			dma_thresh_write << RR_DW_THRESHOLD_SHIFT;
	}

	if (dma_thresh_read != -1) {
		if (dma_thresh_read < 1 || dma_thresh_read > RR_DR_THRESHOLD_MAX)
			usage();
		rr_tune.rt_dma_read_state &= ~RR_DR_THRESHOLD_MASK;
		rr_tune.rt_dma_read_state |= 
			dma_thresh_read << RR_DR_THRESHOLD_SHIFT;
	}

	rr_tune.rt_stats_timer = ESH_STATS_TIMER_DEFAULT;

	if (interrupt_delay != -1)
		rr_tune.rt_interrupt_timer = interrupt_delay;

	if (drvspec_ioctl(name, s, EIOCSTUNE, sizeof(struct rr_tuning),
			  (caddr_t) &rr_tune) < 0)
		err(1, "EIOCSTUNE");
}

/* esh_tune_eeprom
 *
 * Store the current tuning data into the eeprom.
 */

static void
esh_tune_eeprom(void)
{
#define LAST (RR_EE_HEADER_CHECKSUM / RR_EE_WORD_LEN)
#define FIRST (RR_EE_HEADER_CHECKSUM / RR_EE_WORD_LEN)

	u_int32_t	tuning_data[LAST + 1];

	rr_eeprom.ifr_buffer = tuning_data;
	rr_eeprom.ifr_length = sizeof(tuning_data);
	rr_eeprom.ifr_offset = 0;

	if (drvspec_ioctl(name, s, EIOCGEEPROM, sizeof(struct rr_eeprom), 
			  (caddr_t) &rr_eeprom) == -1)
		err(6, "ioctl to retrieve tuning information from EEPROM");

	tuning_data[RR_EE_PCI_STATE / RR_EE_WORD_LEN] =
		rr_tune.rt_pci_state;
	tuning_data[RR_EE_DMA_WRITE_STATE / RR_EE_WORD_LEN] = 
		rr_tune.rt_dma_write_state;
	tuning_data[RR_EE_DMA_READ_STATE / RR_EE_WORD_LEN] = 
		rr_tune.rt_dma_read_state;
	tuning_data[RR_EE_INTERRUPT_TIMER / RR_EE_WORD_LEN] = rr_tune.rt_interrupt_timer;
	tuning_data[RR_EE_STATS_TIMER / RR_EE_WORD_LEN] = 
		ESH_STATS_TIMER_DEFAULT;

	tuning_data[RR_EE_HEADER_CHECKSUM / RR_EE_WORD_LEN] = 
		rr_checksum(&tuning_data[FIRST], LAST - FIRST);

	rr_eeprom.ifr_buffer = tuning_data;
	rr_eeprom.ifr_length = sizeof(tuning_data);
	rr_eeprom.ifr_offset = 0;

	if (drvspec_ioctl(name, s, EIOCSEEPROM, sizeof(struct rr_eeprom),
			  (caddr_t) &rr_eeprom) == -1)
		err(7, "ioctl to set tuning information from EEPROM");
}

/* eeprom_upload
 *
 * Upload the EEPROM from the card and store in the data file.
 */

static void
eeprom_upload(const char *filename)
{
	int fd;

	bzero(eeprom, sizeof(eeprom));
	if ((fd = open(filename, O_WRONLY | O_CREAT, 0644)) < 0)
		err(4, "Couldn't open %s for output", filename);

	rr_eeprom.ifr_buffer = eeprom;
	rr_eeprom.ifr_length = sizeof(eeprom);
	rr_eeprom.ifr_offset = 0;

	if (drvspec_ioctl(name, s, EIOCGEEPROM, sizeof(struct rr_eeprom),
			  (caddr_t) &rr_eeprom) == -1)
		err(5, "ioctl to retrieve all of EEPROM");

	write(fd, eeprom, sizeof(eeprom));
	close(fd);
}

/* eeprom_download
 * 
 * Download into eeprom the contents of a file.  The file is made up
 * of ASCII text;  the first three characters can be ignored, the next
 * four hex characters define an address, the next two characters can
 * be ignored, and the final eight hex characters are the data.
 */

static void
eeprom_download(const char *filename)
{
	FILE *fp;
	struct rr_seg_descr *segd = NULL, *nsegd;
	char id[BUFSIZ];
	char pad[BUFSIZ];
	char buffer[BUFSIZ];
	u_int32_t address = 0;
	u_int32_t last_address = 0;
	u_int32_t value;
	u_int32_t length = 0;
	int segment_start = 0;
	int seg_table_start;
	int seg_count_offset;
	int phase2_start;
	int phase2_checksum;
	int in_segment = 0;
	int segment = 0;
	int eof = 0;
	int line = 0;
	int zero_count = 0;
	int i;

	/* Clear out eeprom storage space, then read in the value on the card */

	bzero(eeprom, sizeof(eeprom));
	bzero(runcode, sizeof(runcode));

	rr_eeprom.ifr_buffer = eeprom;
	rr_eeprom.ifr_length = sizeof(eeprom);
	rr_eeprom.ifr_offset = 0;
	if (drvspec_ioctl(name, s, EIOCGEEPROM, sizeof(struct rr_eeprom),
			  (caddr_t) &rr_eeprom) == -1)
		err(5, "ioctl to retrieve EEPROM");

	/* 
	 * Open the input file and proceed to read the data file, storing
	 * the data and counting the number of segments.
	 */

	if ((fp = fopen(filename, "r")) == NULL)
		err(2, "fopen");

	do {
		if (fgets(buffer, sizeof(buffer), fp) == NULL)
			errx(3, "premature, unmarked end of file, line %d", line);
		line++;

		if (!strncmp(buffer + 7, "01", 2)) { /* check for EOF marker... */
			eof = 1;
		} else {
			sscanf(buffer, "%3s%4x%2s%8x%2s", 
			       id, &address, pad, &value, pad);
			if (strcmp(id, ":04") != 0)
				errx(3, "bad initial id on line %d", line);
		}

		/*
		 * Check to see if we terminated a segment;  this happens
		 * when we are at end of file, or we hit a non-sequential
		 * address value, or we see three or more zeroes in a row.
		 */

		if ((length == RR_EE_SEG_SIZE || eof || zero_count >= 3 ||
		     (last_address && last_address != address - 1)) && in_segment) {

			length -= zero_count;
			segment_start += length;
			segd[segment].length = length;

			printf("segment %d, %d words\n", segment, length);
			last_address = in_segment = zero_count = length = 0;
			segment++;
		}

		if (eof)
			break;

		/* Skip zero values starting a segment */

		if (!in_segment && value == 0)
			continue;
		last_address = address;

		/* 
		 * If we haven't started a segment yet, do so now.
		 * Store away the address at which this code should be placed
		 * in memory and the address of the code in the EEPROM.
		 */

		if (!in_segment) {
			in_segment = 1;

			nsegd = realloc(segd, sizeof(struct rr_seg_descr) * (segment + 1));
			if (nsegd == NULL)
				err(6, "couldn't realloc segment descriptor space");
			segd = nsegd;

			segd[segment].start_addr = address * sizeof(u_int32_t);
			segd[segment].ee_addr = segment_start;
		}

		/* Keep track of consecutive zeroes */

		if (in_segment && value == 0)
			zero_count++;
		else 
			zero_count = 0;

		/* Store away the actual data */

		runcode[segment_start + length++] = value;
	} while (!eof);
	fclose(fp);

	/* Now that we have a segment count, fill in the EEPROM image. */

	seg_count_offset = eeprom[RR_EE_RUNCODE_SEGMENTS / RR_EE_WORD_LEN];
	seg_count_offset = (seg_count_offset - RR_EE_OFFSET) / RR_EE_WORD_LEN;
	seg_table_start = seg_count_offset + 1;
	phase2_checksum = seg_table_start + 3 * segment;
	phase2_start = eeprom[RR_EE_PHASE2_EE_START / RR_EE_WORD_LEN];
	phase2_start = (phase2_start - RR_EE_OFFSET) / RR_EE_WORD_LEN;

	printf("segment table start = %x, segments = %d\n", 
	       seg_table_start, eeprom[seg_count_offset]);

	/* We'll fill in anything after the segment count, so clear it */

	bzero(eeprom + seg_count_offset, 
	      sizeof(eeprom) - seg_count_offset * sizeof(eeprom[0]));

	eeprom[seg_count_offset] = segment;

	for (i = 0; i < segment; i++)
		segd[i].ee_addr = RR_EE_OFFSET + 
			(segd[i].ee_addr + phase2_checksum + 1) * RR_EE_WORD_LEN;

	bcopy(segd, &eeprom[seg_table_start], 
	      sizeof(struct rr_seg_descr) * segment);

	bcopy(runcode, &eeprom[phase2_checksum + 1],
	      segment_start * sizeof(u_int32_t));

	eeprom[phase2_checksum] = rr_checksum(&eeprom[phase2_start],
					      phase2_checksum - phase2_start);

	eeprom[segment_start + phase2_checksum + 1] = 
		rr_checksum(&eeprom[phase2_checksum + 1], segment_start);

	printf("phase2 checksum %x, runcode checksum %x\n",
	       eeprom[phase2_checksum], 
	       eeprom[segment_start + phase2_checksum + 1]);

	rr_eeprom.ifr_buffer = eeprom;
	rr_eeprom.ifr_length = sizeof(eeprom);
	rr_eeprom.ifr_offset = 0;
	if (drvspec_ioctl(name, s, EIOCSEEPROM, sizeof(struct rr_eeprom),
			  (caddr_t) &rr_eeprom) == -1)
		err(5, "ioctl to retrieve EEPROM");
}

/* rr_checksum
 *
 * Perform checksum on RunCode.  Length is in words.  Ugh.
 */

static u_int32_t
rr_checksum(const u_int32_t *data, int length)
{
	u_int32_t checksum = 0;

	while (length--)
		checksum += *data++;

	checksum = 0 - checksum;
	return checksum;
}

static struct stats_values {
	int	 offset;
	const char *name;
} stats_values[] = {
	{0x04, "receive rings created"},
	{0x08, "receive rings deleted"},
	{0x0c, "interrupts"},
	{0x10, "event overflows"},
	{0x14, "invalid commands"},
	{0x18, "DMA read errors"},
	{0x1c, "DMA write errors"},
	{0x20, "stats updates per timer"},
	{0x24, "stats updates per host"},
	{0x28, "watchdog"},
	{0x2c, "trace"},
	{0x30, "link ready sync established"},
	{0x34, "GLink errors"},
	{0x38, "alternating flag errors"},
	{0x3c, "overhead bit 8 synchronized"},
	{0x40, "remote serial parity errors"},
	{0x44, "remote parallel parity errors"},
	{0x48, "remote loopback requested"},
	{0x50, "transmit connections established"},
	{0x54, "transmit connections rejected"},
	{0x58, "transmit connections retried"},
	{0x5c, "transmit connections timed out"},
	{0x60, "transmit connections disconnected"},
	{0x64, "transmit parity errors"},
	{0x68, "packets sent"},
	{0x74, "short first burst sent"},
	{0x80, "transmit data not moving"},
	{0x90, "receive connections accepted"},
	{0x94, "receive connections rejected -- bad parity"},
	{0x98, "receive connections rejected -- 64-bit width"},
	{0x9c, "receive connections rejected -- buffers low"},
	{0xa0, "receive connections disconnected"},
	{0xa4, "receive connections with no data"},
	{0xa8, "packets received"},
	{0xb4, "short first burst received"},
	{0xc0, "receive parity error"},
	{0xc4, "receive LLRC error"},
	{0xc8, "receive burst size error"},
	{0xcc, "receive state error"},
	{0xd0, "receive ready ULP"},
	{0xd4, "receive invalid ULP"},
	{0xd8, "receive packets flow control due to buffer space"},
	{0xdc, "receive packets flow control due to descriptors"},
	{0xe0, "receive ring fulls"},
	{0xe4, "packet length errors"},
	{0xe8, "packets with checksum error"},
	{0xec, "packets dropped"},
	{0xf0, "ring low on space"},
	{0xf4, "data in ring at close"},
	{0xf8, "receives to ring not moving data"},
	{0xfc, "receiver idles"},
	{0, 0},
};

static void
esh_reset(void)
{
	if (drvspec_ioctl(name, s, EIOCRESET, 0, 0) < 0)
		err(1, "ioctl(EIOCRESET)");
}

static void
esh_stats(int lget_stats)
{
	u_int32_t	*stats;
	long long value;
	int offset;

	if (drvspec_ioctl(name, s, EIOCGSTATS, sizeof(struct rr_stats),
			  (caddr_t) &rr_stats) < 0)
		err(1, "ioctl(EIOCGTUNE)");

	stats = rr_stats.rs_stats;

	value = (((long long) stats[0x78 / 4]) << 32) | stats[0x7c / 4];
	if (lget_stats == 1 || value > 0)
		printf("%12lld bytes sent\n", value);
	value = ((long long) stats[0xb8 / 4] << 32) | stats[0xbc / 4];
	if (lget_stats == 1 || value > 0)
		printf("%12lld bytes received\n", value);

	for (offset = 0; stats_values[offset].offset != 0; offset++) {
		if (lget_stats == 1 || stats[stats_values[offset].offset / 4] > 0)
			printf("%12d %s\n", stats[stats_values[offset].offset / 4],
			       stats_values[offset].name);
	}
}


static void
esh_tuning_stats(void)
{
	printf("rt_mode_and_status = %x\n", 
	       rr_tune.rt_mode_and_status);
	printf("rt_conn_retry_count = %x\n", 
	       rr_tune.rt_conn_retry_count);
	printf("rt_conn_retry_timer = %x\n", 
	       rr_tune.rt_conn_retry_timer);
	printf("rt_conn_timeout = %x\n", rr_tune.rt_conn_timeout);
	printf("rt_stats_timer = %x\n", rr_tune.rt_stats_timer);
	printf("rt_interrupt_timer = %x\n", 
	       rr_tune.rt_interrupt_timer);
	printf("rt_tx_timeout = %x\n", rr_tune.rt_tx_timeout);
	printf("rt_rx_timeout = %x\n", rr_tune.rt_rx_timeout);
	printf("rt_pci_state = %x"
	       "     min DMA %x  read max %x write max %x\n", 
	       rr_tune.rt_pci_state,
	       (rr_tune.rt_pci_state & RR_PS_MIN_DMA_MASK) 
	       >> RR_PS_MIN_DMA_SHIFT,
	       do_map_dma(rr_tune.rt_pci_state & RR_PS_READ_MASK,
			  read_dma_map),
	       do_map_dma(rr_tune.rt_pci_state & RR_PS_WRITE_MASK,
			  write_dma_map));
	printf("rt_dma_write_state = %x\n", 
	       rr_tune.rt_dma_write_state);
	printf("rt_dma_read_state = %x\n", rr_tune.rt_dma_read_state);
	printf("rt_driver_param = %x\n", rr_tune.rt_driver_param);

}