/*	$NetBSD: ctu.c,v 1.39 2023/12/20 15:34:45 thorpej Exp $ */
/*
 * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
 * All rights reserved.
 *
 * 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 AUTHOR ``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 AUTHOR 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.
 */

/*
 * Device driver for 11/750 Console TU58.
 *
 * Writing of tapes does not work, by some unknown reason so far.
 * It is almost useless to try to use this driver when running
 * multiuser, because the serial device don't have any buffers 
 * so we will lose interrupts.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ctu.c,v 1.39 2023/12/20 15:34:45 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/callout.h>
#include <sys/conf.h>
#include <sys/cpu.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/kernel.h>
#include <sys/proc.h>

#include <machine/rsp.h>
#include <machine/scb.h>

#undef TUDEBUG

#define	TU_IDLE		0
#define	TU_RESET	1
#define	TU_RUNNING	2
#define	TU_WORKING	3
#define TU_READING	4
#define TU_WRITING	5
#define	TU_ENDPACKET	6
#define	TU_RESTART	7

struct tu_softc {
	int	sc_state;
	int	sc_step;
	char	sc_rsp[15];	/* Should be struct rsb; but don't work */
	int	sc_tpblk;	/* Start block number */
	int 	sc_wto;		/* Timeout counter */
	int	sc_xbytes;	/* Number of xfer'd bytes */
	int	sc_op;		/* Read/write */
	struct	bufq_state *sc_bufq;	/* pending I/O requests */
} tu_sc;

struct	ivec_dsp tu_recv, tu_xmit;

	void ctuattach(void);
static	void ctutintr(void *);
static	void cturintr(void *);
static	void ctustart(void);
static	void ctuwatch(void *);
static	u_short ctu_cksum(unsigned short *, int);

dev_type_open(ctuopen);
dev_type_close(ctuclose);
#if 0 /* not yet */
dev_type_read(cturead);
dev_type_write(ctuwrite);
#endif
dev_type_strategy(ctustrategy);

const struct bdevsw ctu_bdevsw = {
	.d_open = ctuopen,
	.d_close = ctuclose,
	.d_strategy = ctustrategy,
	.d_ioctl = noioctl,
	.d_dump = nodump,
	.d_psize = nosize,
	.d_discard = nodiscard,
	.d_flag = D_TAPE
};

#if 0 /* not yet */
const struct cdevsw ctu_cdevsw = {
	.d_open = ctuopen,
	.d_close = ctuclose,
	.d_read = cturead,
	.d_write = ctuwrite,
	.d_ioctl = noioctl,
	.d_stop = nostop,
	.d_tty = notty,
	.d_poll = nopoll,
	.d_mmap = nommap,
	.d_kqfilter = nokqfilter,
	.d_discard = nodiscard,
	.d_flag = D_TAPE
};
#endif

static callout_t ctu_watch_ch;

void
ctuattach(void)
{

	callout_init(&ctu_watch_ch, 0);
	bufq_alloc(&tu_sc.sc_bufq, "fcfs", 0);

	tu_recv = idsptch;
	tu_recv.hoppaddr = cturintr;
	scb->scb_csrint = (void *)&tu_recv;

	tu_xmit = idsptch;
	tu_xmit.hoppaddr = ctutintr;
	scb->scb_cstint = (void *)&tu_xmit;
}

static void
ctuinit(void)
{
	int s = spl7();
#define	WAIT	while ((mfpr(PR_CSTS) & 0x80) == 0)

	/*
	 * Do a reset as described in the
	 * "TU58 DECtape II Users Guide".
	 */
	mtpr(0101, PR_CSTS);	/* Enable transmit interrupt + send break */
	WAIT;
	mtpr(0, PR_CSTD); WAIT;
	mtpr(0, PR_CSTD); WAIT;
	mtpr(RSP_TYP_INIT, PR_CSTD); WAIT;
	mtpr(RSP_TYP_INIT, PR_CSTD); WAIT;
#undef	WAIT
	splx(s);
}

int
ctuopen(dev_t dev, int oflags, int devtype, struct lwp *l)
{
	int error;

	if (minor(dev))
		return ENXIO;

	if (tu_sc.sc_state != TU_IDLE)
		return EBUSY;

	tu_sc.sc_state = TU_RESET;
	tu_sc.sc_step = 0;
	mtpr(0100, PR_CSRS);	/* Enable receive interrupt */
	mtpr(0101, PR_CSTS);	/* Enable transmit interrupt + send break */
	if ((error = tsleep((void *)&tu_sc, (PZERO + 10)|PCATCH, "reset", 0)))
		return error;
	
#ifdef TUDEBUG
	printf("ctuopen: running\n");
#endif
	tu_sc.sc_state = TU_RUNNING;
	callout_reset(&ctu_watch_ch, hz, ctuwatch, NULL);
	return 0;

}

int
ctuclose(dev_t dev, int oflags, int devtype, struct lwp *l)
{
	struct buf *bp;
	int s = spl7();
	while ((bp = bufq_get(tu_sc.sc_bufq)))
		;
	splx(s);

	mtpr(0, PR_CSRS);
	mtpr(0, PR_CSTS);
	tu_sc.sc_state = TU_IDLE;
	callout_stop(&ctu_watch_ch);
	return 0;
}

void
ctustrategy(struct buf *bp)
{
	int s, empty;

#ifdef TUDEBUG
	printf("ctustrategy: bcount %ld blkno %d\n", bp->b_bcount, bp->b_blkno);
	printf("ctustrategy: bp %p\n", bp);
#endif
	s = spl7();
	if (bp->b_blkno >= 512) {
		bp->b_resid = bp->b_bcount;
		biodone(bp);
		splx(s);
		return;
	}

	empty = (bufq_peek(tu_sc.sc_bufq) == NULL);
	bufq_put(tu_sc.sc_bufq, bp);
	if (empty)
		ctustart();
	splx(s);
}

void
ctustart(void)
{
	struct rsp *rsp = (struct rsp *)tu_sc.sc_rsp;
	struct buf *bp;

	bp = bufq_peek(tu_sc.sc_bufq);
	if (bp == NULL)
		return;
#ifdef TUDEBUG
	printf("ctustart: %s\n", bp->b_flags & B_READ ? "READING":"WRITING");
#endif
	tu_sc.sc_tpblk = bp->b_blkno;
	tu_sc.sc_xbytes = 0;
	tu_sc.sc_op = bp->b_flags & B_READ ? RSP_OP_READ : RSP_OP_WRITE;
	tu_sc.sc_step = 0;
	bp->b_resid = bp->b_bcount;
	tu_sc.sc_wto = 0;

	rsp->rsp_typ = RSP_TYP_COMMAND;
	rsp->rsp_sz = 012;
	rsp->rsp_op = tu_sc.sc_op;
	rsp->rsp_mod = 0;
	rsp->rsp_drv = 0;
	rsp->rsp_sw = rsp->rsp_xx1 = rsp->rsp_xx2 = 0;
	rsp->rsp_cnt = bp->b_bcount;
	rsp->rsp_blk = tu_sc.sc_tpblk;
	rsp->rsp_sum = ctu_cksum((unsigned short *)rsp, 6);
	tu_sc.sc_state = TU_WORKING;
	ctutintr(NULL);
}

static int
readchr(void)
{
	int i;

	for (i = 0; i < 5000; i++)
		if ((mfpr(PR_CSRS) & 0x80))
			break;
	if (i == 5000)
		return -1;
	return mfpr(PR_CSRD);
}

/*
 * Loop in a tight (busy-wait-)loop when receiving packets, this is
 * the only way to avoid loosing characters.
 */
void
cturintr(void *arg)
{
	int status = mfpr(PR_CSRD);
	struct	buf *bp;
	int i, c, tck;
	unsigned short ck = 0;
	char *buf;

	bp = bufq_peek(tu_sc.sc_bufq);
	buf = bp->b_data;
	switch (tu_sc.sc_state) {
	case TU_RESET:
		if (status != RSP_TYP_CONTINUE)
			printf("Bad response %d\n", status);
		wakeup(&tu_sc);
		return;

	case TU_READING:
		if (status != RSP_TYP_DATA)
			bp->b_error = EIO;
		tu_sc.sc_wto = 0;
		for (i = 0; i < 131; i++) {
			if ((c = readchr()) < 0) {
#ifdef TUDEBUG
				printf("Timeout...%d\n", i);
#endif
				goto bad;
			}
			if ((i > 0) && (i < 129))
				buf[tu_sc.sc_xbytes++] = c;
			if (i == 129)
				ck = (c & 0xff);
			if (i == 130)
				ck |= ((c & 0xff) << 8);
		}
		tck = ctu_cksum((void *)&buf[tu_sc.sc_xbytes-128], 64);
		tck += 0x8001; if (tck > 0xffff) tck -= 0xffff;
		if (tck != ck) {
#ifdef TUDEBUG
			int i;
			printf("Bad cksum: tck %x != ck %x\n", tck, ck);
			printf("block %d\n", tu_sc.sc_xbytes/128-1);
			for (i = -128; i < 0; i+=16)
				printf("%x %x %x %x\n",
				    *(int *)&bp->b_data[tu_sc.sc_xbytes+i],
				    *(int *)&bp->b_data[tu_sc.sc_xbytes+i+4],
				    *(int *)&bp->b_data[tu_sc.sc_xbytes+i+8],
				    *(int *)&bp->b_data[tu_sc.sc_xbytes+i+12]);
#endif
			goto bad;
		}
		bp->b_resid = 0;
		if (bp->b_bcount == tu_sc.sc_xbytes)
			tu_sc.sc_state = TU_ENDPACKET;
		return;

	case TU_ENDPACKET:
		if (status != RSP_TYP_COMMAND) {
#ifdef TUDEBUG
			int g[14], j;
			g[0] = status;
			for (i = 1; i < 14; i++)
				if ((g[i] = readchr()) < 0)
					break;
			j=0; while (readchr() >= 0)
				j++;
			for (i = 0; i < 14; i++)
				printf("%d: %x\n", i, g[i]);
			printf("Got %d char more\n", j);
			printf("error: state %d xbytes %d status %d\n",
			    tu_sc.sc_state, tu_sc.sc_xbytes, status);
#endif
			
			bp->b_error = EIO;
		}
		tu_sc.sc_wto = 0;
		for (i = 0; i < 13; i++) {
			if ((c = readchr()) < 0) {
#ifdef TUDEBUG
				printf("Timeout epack %d\n", i);
#endif
				goto bad;
			}
			if ((i == 2) &&
			    ((c != RSP_MOD_OK) && (c != RSP_MOD_RETR))) {
#ifdef TUDEBUG
				printf("end packet status bad: %d\n", c);
#endif
				bp->b_error = EIO;
			}
		}
		break;

	case TU_WRITING:
#define	WAIT	while ((mfpr(PR_CSTS) & 0x80) == 0)

		if (status != RSP_TYP_CONTINUE)
			goto bad;
#ifdef TUDEBUG
		printf("Writing byte %d\n", tu_sc.sc_xbytes);
#endif
		WAIT;
		mtpr(RSP_TYP_DATA, PR_CSTD);
		WAIT;
		mtpr(128, PR_CSTD);
		for (i = 0; i < 128; i++) {
			WAIT;
			mtpr(buf[tu_sc.sc_xbytes++], PR_CSTD);
		}
		tck = ctu_cksum((void *)&buf[tu_sc.sc_xbytes-128], 64);
		tck += 0x8001; if (tck > 0xffff) tck -= 0xffff;
		WAIT;
		mtpr(tck & 0xff, PR_CSTD);
		WAIT;
		mtpr((tck >> 8) & 0xff, PR_CSTD);
		bp->b_resid = 0;
		if (tu_sc.sc_xbytes == bp->b_bcount)
			tu_sc.sc_state = TU_ENDPACKET;
		return;
#undef WAIT

	case TU_RESTART:
		if (status != RSP_TYP_CONTINUE)
			goto bad;
		ctustart();
		return;

	default:
		printf("bad rx state %d char %d\n", tu_sc.sc_state, status);
		return;
	}
	if (bp->b_error == 0) {
		(void)bufq_get(tu_sc.sc_bufq);
		biodone(bp);
#ifdef TUDEBUG
		printf("biodone %p\n", bp);
#endif
	}
#ifdef TUDEBUG
	  else {
		printf("error: state %d xbytes %d status %d\n",
		    tu_sc.sc_state, tu_sc.sc_xbytes, status);
	}
#endif
	bp->b_error = 0;
	tu_sc.sc_state = TU_IDLE;
	ctustart();
	return;

bad:	tu_sc.sc_state = TU_RESTART;
	ctuinit();
}

void
ctutintr(void *arg)
{
	while ((mfpr(PR_CSTS) & 0x80) == 0)
		;
	switch (tu_sc.sc_state) {
	case TU_RESET:
		switch (tu_sc.sc_step) {
		case 0:
		case 1:
			mtpr(0, PR_CSTD);
			break;
		case 2:
		case 3:
			mtpr(RSP_TYP_INIT, PR_CSTD);
			break;
		default:
			break;
		}
		tu_sc.sc_step++;
		return;

	case TU_WORKING:
		if (tu_sc.sc_step == 14) {
			if (tu_sc.sc_op == RSP_OP_READ)
				tu_sc.sc_state = TU_READING;
			else
				tu_sc.sc_state = TU_WRITING;
		} else
			mtpr(tu_sc.sc_rsp[tu_sc.sc_step++], PR_CSTD);
		return;

	case TU_IDLE:
		printf("Idle interrupt\n");
		return;

	case TU_ENDPACKET:
	case TU_WRITING:
	case TU_RESTART:
		return;

	default:
		printf("bad tx state %d\n", tu_sc.sc_state);
	}
}

unsigned short
ctu_cksum(unsigned short *buf, int words)
{
	int i, cksum;

	for (i = cksum = 0; i < words; i++)
		cksum += buf[i];

hej:	if (cksum > 65535) {
		cksum = (cksum & 65535) + (cksum >> 16);
		goto hej;
	}
	return cksum;
}

int	oldtp;

/*
 * Watch so that we don't get blocked unnecessary due to lost int's.
 */
void
ctuwatch(void *arg)
{

	callout_reset(&ctu_watch_ch, hz, ctuwatch, NULL);

	if (tu_sc.sc_state == TU_WORKING) {
		/*
		 * Died in sending command.
		 * Wait 5 secs.
		 */
		if (tu_sc.sc_wto++ > 5) {
#ifdef TUDEBUG
			printf("Died in sending command\n");
#endif
			tu_sc.sc_state = TU_RESTART;
			ctuinit();
		}
	}
	if (tu_sc.sc_state == TU_READING || tu_sc.sc_state == TU_WRITING) {
		/*
		 * Positioning, may take long time.
		 * Wait one minute.
		 */
		if (tu_sc.sc_wto++ > 60) {
#ifdef TUDEBUG
			printf("Died in Positioning, wto %d\n", tu_sc.sc_wto);
#endif
			tu_sc.sc_state = TU_RESTART;
			ctuinit();
		}
	}
}