[linux-block.git] / arch / m68k / include / asm / sun3xflop.h

/* SPDX-License-Identifier: GPL-2.0 */
/* sun3xflop.h: Sun3/80 specific parts of the floppy driver.
 *
 * Derived partially from asm-sparc/floppy.h, which is:
 *     Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 *
 * Sun3x version 2/4/2000 Sam Creasey (sammy@sammy.net)
 */

#ifndef __ASM_SUN3X_FLOPPY_H
#define __ASM_SUN3X_FLOPPY_H

#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
#include <asm/sun3x.h>

/* default interrupt vector */
#define SUN3X_FDC_IRQ 0x40

/* some constants */
#define FCR_TC 0x1
#define FCR_EJECT 0x2
#define FCR_MTRON 0x4
#define FCR_DSEL1 0x8
#define FCR_DSEL0 0x10

/* We don't need no stinkin' I/O port allocation crap. */
#undef release_region
#undef request_region
#define release_region(X, Y)	do { } while(0)
#define request_region(X, Y, Z)	(1)

struct sun3xflop_private {
	volatile unsigned char *status_r;
	volatile unsigned char *data_r;
	volatile unsigned char *fcr_r;
	volatile unsigned char *fvr_r;
	unsigned char fcr;
} sun3x_fdc;

/* Super paranoid... */
#undef HAVE_DISABLE_HLT

/* Routines unique to each controller type on a Sun. */
static unsigned char sun3x_82072_fd_inb(int port)
{
	static int once = 0;
//	udelay(5);
	switch(port & 7) {
	default:
		pr_crit("floppy: Asked to read unknown port %d\n", port);
		panic("floppy: Port bolixed.");
	case 4: /* FD_STATUS */
		return (*sun3x_fdc.status_r) & ~STATUS_DMA;
	case 5: /* FD_DATA */
		return (*sun3x_fdc.data_r);
	case 7: /* FD_DIR */
		/* ugly hack, I can't find a way to actually detect the disk */
		if(!once) {
			once = 1;
			return 0x80;
		}
		return 0;
	};
	panic("sun_82072_fd_inb: How did I get here?");
}

static void sun3x_82072_fd_outb(unsigned char value, int port)
{
//	udelay(5);
	switch(port & 7) {
	default:
		pr_crit("floppy: Asked to write to unknown port %d\n", port);
		panic("floppy: Port bolixed.");
	case 2: /* FD_DOR */
		/* Oh geese, 82072 on the Sun has no DOR register,
		 * so we make do with taunting the FCR.
		 *
		 * ASSUMPTIONS:  There will only ever be one floppy
		 *               drive attached to a Sun controller
		 *               and it will be at drive zero.
		 */

	{
		unsigned char fcr = sun3x_fdc.fcr;

		if(value & 0x10) {
			fcr |= (FCR_DSEL0 | FCR_MTRON);
		} else
			fcr &= ~(FCR_DSEL0 | FCR_MTRON);


		if(fcr != sun3x_fdc.fcr) {
			*(sun3x_fdc.fcr_r) = fcr;
			sun3x_fdc.fcr = fcr;
		}
	}
		break;
	case 5: /* FD_DATA */
		*(sun3x_fdc.data_r) = value;
		break;
	case 7: /* FD_DCR */
		*(sun3x_fdc.status_r) = value;
		break;
	case 4: /* FD_STATUS */
		*(sun3x_fdc.status_r) = value;
		break;
	};
	return;
}


asmlinkage irqreturn_t sun3xflop_hardint(int irq, void *dev_id)
{
	register unsigned char st;

#undef TRACE_FLPY_INT
#define NO_FLOPPY_ASSEMBLER

#ifdef TRACE_FLPY_INT
	static int calls=0;
	static int bytes=0;
	static int dma_wait=0;
#endif
	if(!doing_pdma) {
		floppy_interrupt(irq, dev_id);
		return IRQ_HANDLED;
	}

//	pr_info("doing pdma\n");// st %x\n", sun_fdc->status_82072);

#ifdef TRACE_FLPY_INT
	if(!calls)
		bytes = virtual_dma_count;
#endif

	{
		register int lcount;
		register char *lptr;

		for(lcount=virtual_dma_count, lptr=virtual_dma_addr;
		    lcount; lcount--, lptr++) {
/*			st=fd_inb(virtual_dma_port+4) & 0x80 ;  */
			st = *(sun3x_fdc.status_r);
/*			if(st != 0xa0)                  */
/*				break;                  */

			if((st & 0x80) == 0) {
				virtual_dma_count = lcount;
				virtual_dma_addr = lptr;
				return IRQ_HANDLED;
			}

			if((st & 0x20) == 0)
				break;

			if(virtual_dma_mode)
/*				fd_outb(*lptr, virtual_dma_port+5); */
				*(sun3x_fdc.data_r) = *lptr;
			else
/*				*lptr = fd_inb(virtual_dma_port+5); */
				*lptr = *(sun3x_fdc.data_r);
		}

		virtual_dma_count = lcount;
		virtual_dma_addr = lptr;
/*		st = fd_inb(virtual_dma_port+4);   */
		st = *(sun3x_fdc.status_r);
	}

#ifdef TRACE_FLPY_INT
	calls++;
#endif
//	pr_info("st=%02x\n", st);
	if(st == 0x20)
		return IRQ_HANDLED;
	if(!(st & 0x20)) {
		virtual_dma_residue += virtual_dma_count;
		virtual_dma_count=0;
		doing_pdma = 0;

#ifdef TRACE_FLPY_INT
		pr_info("count=%x, residue=%x calls=%d bytes=%x dma_wait=%d\n",
			virtual_dma_count, virtual_dma_residue, calls, bytes,
			dma_wait);
		calls = 0;
		dma_wait=0;
#endif

		floppy_interrupt(irq, dev_id);
		return IRQ_HANDLED;
	}


#ifdef TRACE_FLPY_INT
	if(!virtual_dma_count)
		dma_wait++;
#endif
	return IRQ_HANDLED;
}

static int sun3xflop_request_irq(void)
{
	static int once = 0;
	int error;

	if(!once) {
		once = 1;
		error = request_irq(FLOPPY_IRQ, sun3xflop_hardint,
				    0, "floppy", NULL);
		return ((error == 0) ? 0 : -1);
	} else return 0;
}

static void __init floppy_set_flags(int *ints,int param, int param2);

static int sun3xflop_init(void)
{
	if(FLOPPY_IRQ < 0x40)
		FLOPPY_IRQ = SUN3X_FDC_IRQ;

	sun3x_fdc.status_r = (volatile unsigned char *)SUN3X_FDC;
	sun3x_fdc.data_r  = (volatile unsigned char *)(SUN3X_FDC+1);
	sun3x_fdc.fcr_r = (volatile unsigned char *)SUN3X_FDC_FCR;
	sun3x_fdc.fvr_r = (volatile unsigned char *)SUN3X_FDC_FVR;
	sun3x_fdc.fcr = 0;

	/* Last minute sanity check... */
	if(*sun3x_fdc.status_r == 0xff) {
		return -1;
	}

	*sun3x_fdc.fvr_r = FLOPPY_IRQ;

	*sun3x_fdc.fcr_r = FCR_TC;
	udelay(10);
	*sun3x_fdc.fcr_r = 0;

	/* Success... */
	floppy_set_flags(NULL, 1, FD_BROKEN_DCL); // I don't know how to detect this.
	allowed_drive_mask = 0x01;
	return (int) SUN3X_FDC;
}

/* I'm not precisely sure this eject routine works */
static int sun3x_eject(void)
{
	if(MACH_IS_SUN3X) {

		sun3x_fdc.fcr |= (FCR_DSEL0 | FCR_EJECT);
		*(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
		udelay(10);
		sun3x_fdc.fcr &= ~(FCR_DSEL0 | FCR_EJECT);
		*(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
	}

	return 0;
}

#define fd_eject(drive) sun3x_eject()

#endif /* !(__ASM_SUN3X_FLOPPY_H) */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	2	/* sun3xflop.h: Sun3/80 specific parts of the floppy driver.
	3	*
	4	* Derived partially from asm-sparc/floppy.h, which is:
	5	* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
	6	*
	7	* Sun3x version 2/4/2000 Sam Creasey (sammy@sammy.net)
	8	*/
	9
	10	#ifndef __ASM_SUN3X_FLOPPY_H
	11	#define __ASM_SUN3X_FLOPPY_H
	12
	13	#include <asm/page.h>
	14	#include <asm/pgtable.h>
1da177e4 LT	15	#include <asm/irq.h>
	16	#include <asm/sun3x.h>
	17
	18	/* default interrupt vector */
	19	#define SUN3X_FDC_IRQ 0x40
	20
	21	/* some constants */
	22	#define FCR_TC 0x1
	23	#define FCR_EJECT 0x2
	24	#define FCR_MTRON 0x4
	25	#define FCR_DSEL1 0x8
	26	#define FCR_DSEL0 0x10
	27
	28	/* We don't need no stinkin' I/O port allocation crap. */
	29	#undef release_region
1da177e4 LT	30	#undef request_region
1da177e4 LT	31	#define release_region(X, Y) do { } while(0)
1da177e4 LT	32	#define request_region(X, Y, Z) (1)
	33
	34	struct sun3xflop_private {
	35	volatile unsigned char *status_r;
	36	volatile unsigned char *data_r;
	37	volatile unsigned char *fcr_r;
	38	volatile unsigned char *fvr_r;
	39	unsigned char fcr;
	40	} sun3x_fdc;
	41
	42	/* Super paranoid... */
	43	#undef HAVE_DISABLE_HLT
	44
	45	/* Routines unique to each controller type on a Sun. */
	46	static unsigned char sun3x_82072_fd_inb(int port)
	47	{
	48	static int once = 0;
	49	// udelay(5);
	50	switch(port & 7) {
	51	default:
4eee1e72	52	pr_crit("floppy: Asked to read unknown port %d\n", port);
1da177e4 LT	53	panic("floppy: Port bolixed.");
	54	case 4: /* FD_STATUS */
	55	return (*sun3x_fdc.status_r) & ~STATUS_DMA;
	56	case 5: /* FD_DATA */
	57	return (*sun3x_fdc.data_r);
	58	case 7: /* FD_DIR */
	59	/* ugly hack, I can't find a way to actually detect the disk */
	60	if(!once) {
	61	once = 1;
	62	return 0x80;
	63	}
	64	return 0;
	65	};
	66	panic("sun_82072_fd_inb: How did I get here?");
	67	}
	68
	69	static void sun3x_82072_fd_outb(unsigned char value, int port)
	70	{
	71	// udelay(5);
	72	switch(port & 7) {
	73	default:
4eee1e72	74	pr_crit("floppy: Asked to write to unknown port %d\n", port);
1da177e4 LT	75	panic("floppy: Port bolixed.");
	76	case 2: /* FD_DOR */
	77	/* Oh geese, 82072 on the Sun has no DOR register,
	78	* so we make do with taunting the FCR.
	79	*
	80	* ASSUMPTIONS: There will only ever be one floppy
	81	* drive attached to a Sun controller
	82	* and it will be at drive zero.
	83	*/
	84
	85	{
	86	unsigned char fcr = sun3x_fdc.fcr;
	87
	88	if(value & 0x10) {
	89	fcr \|= (FCR_DSEL0 \| FCR_MTRON);
	90	} else
	91	fcr &= ~(FCR_DSEL0 \| FCR_MTRON);
	92
	93
	94	if(fcr != sun3x_fdc.fcr) {
	95	*(sun3x_fdc.fcr_r) = fcr;
	96	sun3x_fdc.fcr = fcr;
	97	}
	98	}
	99	break;
	100	case 5: /* FD_DATA */
	101	*(sun3x_fdc.data_r) = value;
	102	break;
	103	case 7: /* FD_DCR */
	104	*(sun3x_fdc.status_r) = value;
	105	break;
	106	case 4: /* FD_STATUS */
	107	*(sun3x_fdc.status_r) = value;
	108	break;
	109	};
	110	return;
	111	}
	112
	113
2850bc27	114	asmlinkage irqreturn_t sun3xflop_hardint(int irq, void *dev_id)
1da177e4 LT	115	{
	116	register unsigned char st;
	117
	118	#undef TRACE_FLPY_INT
	119	#define NO_FLOPPY_ASSEMBLER
	120
	121	#ifdef TRACE_FLPY_INT
	122	static int calls=0;
	123	static int bytes=0;
	124	static int dma_wait=0;
	125	#endif
	126	if(!doing_pdma) {
2850bc27	127	floppy_interrupt(irq, dev_id);
1da177e4 LT	128	return IRQ_HANDLED;
	129	}
	130
4eee1e72	131	// pr_info("doing pdma\n");// st %x\n", sun_fdc->status_82072);
1da177e4 LT	132
	133	#ifdef TRACE_FLPY_INT
	134	if(!calls)
	135	bytes = virtual_dma_count;
	136	#endif
	137
	138	{
	139	register int lcount;
	140	register char *lptr;
	141
	142	for(lcount=virtual_dma_count, lptr=virtual_dma_addr;
	143	lcount; lcount--, lptr++) {
	144	/* st=fd_inb(virtual_dma_port+4) & 0x80 ; */
	145	st = *(sun3x_fdc.status_r);
	146	/* if(st != 0xa0) */
	147	/* break; */
	148
	149	if((st & 0x80) == 0) {
	150	virtual_dma_count = lcount;
	151	virtual_dma_addr = lptr;
	152	return IRQ_HANDLED;
	153	}
	154
	155	if((st & 0x20) == 0)
	156	break;
	157
	158	if(virtual_dma_mode)
	159	/* fd_outb(lptr, virtual_dma_port+5); /
	160	(sun3x_fdc.data_r) = lptr;
	161	else
	162	/* lptr = fd_inb(virtual_dma_port+5); /
	163	lptr = (sun3x_fdc.data_r);
	164	}
	165
	166	virtual_dma_count = lcount;
	167	virtual_dma_addr = lptr;
	168	/* st = fd_inb(virtual_dma_port+4); */
	169	st = *(sun3x_fdc.status_r);
	170	}
	171
	172	#ifdef TRACE_FLPY_INT
	173	calls++;
	174	#endif
4eee1e72	175	// pr_info("st=%02x\n", st);
1da177e4 LT	176	if(st == 0x20)
	177	return IRQ_HANDLED;
	178	if(!(st & 0x20)) {
	179	virtual_dma_residue += virtual_dma_count;
	180	virtual_dma_count=0;
	181	doing_pdma = 0;
	182
	183	#ifdef TRACE_FLPY_INT
4eee1e72 GU	184	pr_info("count=%x, residue=%x calls=%d bytes=%x dma_wait=%d\n",
	185	virtual_dma_count, virtual_dma_residue, calls, bytes,
	186	dma_wait);
1da177e4 LT	187	calls = 0;
	188	dma_wait=0;
	189	#endif
	190
2850bc27	191	floppy_interrupt(irq, dev_id);
1da177e4 LT	192	return IRQ_HANDLED;
	193	}
	194
	195
	196	#ifdef TRACE_FLPY_INT
	197	if(!virtual_dma_count)
	198	dma_wait++;
	199	#endif
	200	return IRQ_HANDLED;
	201	}
	202
	203	static int sun3xflop_request_irq(void)
	204	{
	205	static int once = 0;
	206	int error;
	207
	208	if(!once) {
	209	once = 1;
b0b9fdc1	210	error = request_irq(FLOPPY_IRQ, sun3xflop_hardint,
77a42796	211	0, "floppy", NULL);
1da177e4 LT	212	return ((error == 0) ? 0 : -1);
	213	} else return 0;
	214	}
	215
	216	static void __init floppy_set_flags(int *ints,int param, int param2);
	217
	218	static int sun3xflop_init(void)
	219	{
	220	if(FLOPPY_IRQ < 0x40)
	221	FLOPPY_IRQ = SUN3X_FDC_IRQ;
	222
	223	sun3x_fdc.status_r = (volatile unsigned char *)SUN3X_FDC;
	224	sun3x_fdc.data_r = (volatile unsigned char *)(SUN3X_FDC+1);
	225	sun3x_fdc.fcr_r = (volatile unsigned char *)SUN3X_FDC_FCR;
	226	sun3x_fdc.fvr_r = (volatile unsigned char *)SUN3X_FDC_FVR;
	227	sun3x_fdc.fcr = 0;
	228
	229	/* Last minute sanity check... */
	230	if(*sun3x_fdc.status_r == 0xff) {
	231	return -1;
	232	}
	233
	234	*sun3x_fdc.fvr_r = FLOPPY_IRQ;
	235
	236	*sun3x_fdc.fcr_r = FCR_TC;
	237	udelay(10);
	238	*sun3x_fdc.fcr_r = 0;
	239
	240	/* Success... */
a5d361fc	241	floppy_set_flags(NULL, 1, FD_BROKEN_DCL); // I don't know how to detect this.
1da177e4 LT	242	allowed_drive_mask = 0x01;
	243	return (int) SUN3X_FDC;
	244	}
	245
	246	/* I'm not precisely sure this eject routine works */
	247	static int sun3x_eject(void)
	248	{
	249	if(MACH_IS_SUN3X) {
	250
	251	sun3x_fdc.fcr \|= (FCR_DSEL0 \| FCR_EJECT);
	252	*(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
	253	udelay(10);
	254	sun3x_fdc.fcr &= ~(FCR_DSEL0 \| FCR_EJECT);
	255	*(sun3x_fdc.fcr_r) = sun3x_fdc.fcr;
	256	}
	257
	258	return 0;
	259	}
	260
	261	#define fd_eject(drive) sun3x_eject()
	262
	263	#endif /* !(__ASM_SUN3X_FLOPPY_H) */