1/* asm-sparc/floppy.h: Sparc specific parts of the Floppy driver.
2 *
3 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
4 */
5
6#ifndef __ASM_SPARC_FLOPPY_H
7#define __ASM_SPARC_FLOPPY_H
8
9#include <asm/page.h>
10#include <asm/pgtable.h>
11#include <asm/system.h>
12#include <asm/idprom.h>
13#include <asm/machines.h>
14#include <asm/oplib.h>
15#include <asm/auxio.h>
16#include <asm/irq.h>
17
18/* We don't need no stinkin' I/O port allocation crap. */
19#undef release_region
20#undef request_region
21#define release_region(X, Y)	do { } while(0)
22#define request_region(X, Y, Z)	(1)
23
24/* References:
25 * 1) Netbsd Sun floppy driver.
26 * 2) NCR 82077 controller manual
27 * 3) Intel 82077 controller manual
28 */
29struct sun_flpy_controller {
30	volatile unsigned char status_82072;  /* Main Status reg. */
31#define dcr_82072              status_82072   /* Digital Control reg. */
32#define status1_82077          status_82072   /* Auxiliary Status reg. 1 */
33
34	volatile unsigned char data_82072;    /* Data fifo. */
35#define status2_82077          data_82072     /* Auxiliary Status reg. 2 */
36
37	volatile unsigned char dor_82077;     /* Digital Output reg. */
38	volatile unsigned char tapectl_82077; /* What the? Tape control reg? */
39
40	volatile unsigned char status_82077;  /* Main Status Register. */
41#define drs_82077              status_82077   /* Digital Rate Select reg. */
42
43	volatile unsigned char data_82077;    /* Data fifo. */
44	volatile unsigned char ___unused;
45	volatile unsigned char dir_82077;     /* Digital Input reg. */
46#define dcr_82077              dir_82077      /* Config Control reg. */
47};
48
49/* You'll only ever find one controller on a SparcStation anyways. */
50static struct sun_flpy_controller *sun_fdc = NULL;
51volatile unsigned char *fdc_status;
52
53struct sun_floppy_ops {
54	unsigned char (*fd_inb)(int port);
55	void (*fd_outb)(unsigned char value, int port);
56};
57
58static struct sun_floppy_ops sun_fdops;
59
60#define fd_inb(port)              sun_fdops.fd_inb(port)
61#define fd_outb(value,port)       sun_fdops.fd_outb(value,port)
62#define fd_enable_dma()           sun_fd_enable_dma()
63#define fd_disable_dma()          sun_fd_disable_dma()
64#define fd_request_dma()          (0) /* nothing... */
65#define fd_free_dma()             /* nothing... */
66#define fd_clear_dma_ff()         /* nothing... */
67#define fd_set_dma_mode(mode)     sun_fd_set_dma_mode(mode)
68#define fd_set_dma_addr(addr)     sun_fd_set_dma_addr(addr)
69#define fd_set_dma_count(count)   sun_fd_set_dma_count(count)
70#define fd_enable_irq()           /* nothing... */
71#define fd_disable_irq()          /* nothing... */
72#define fd_cacheflush(addr, size) /* nothing... */
73#define fd_request_irq()          sun_fd_request_irq()
74#define fd_free_irq()             /* nothing... */
75
76#define FLOPPY_MOTOR_MASK         0x10
77
78#define get_dma_residue(x)        (0)
79
80#define FLOPPY0_TYPE  4
81#define FLOPPY1_TYPE  0
82
83/* Super paranoid... */
84#undef HAVE_DISABLE_HLT
85
86/* Here is where we catch the floppy driver trying to initialize,
87 * therefore this is where we call the PROM device tree probing
88 * routine etc. on the Sparc.
89 */
90#define FDC1                      sun_floppy_init()
91
92#define N_FDC    1
93#define N_DRIVE  8
94
95/* No 64k boundary crossing problems on the Sparc. */
96#define CROSS_64KB(a,s) (0)
97
98/* Routines unique to each controller type on a Sun. */
99static unsigned char sun_82072_fd_inb(int port)
100{
101	udelay(5);
102	switch(port & 7) {
103	default:
104		printk("floppy: Asked to read unknown port %d\n", port);
105		panic("floppy: Port bolixed.");
106	case 4: /* FD_STATUS */
107		return sun_fdc->status_82072 & ~STATUS_DMA;
108	case 5: /* FD_DATA */
109		return sun_fdc->data_82072;
110	case 7: /* FD_DIR */
111		return (get_auxio() & AUXIO_FLPY_DCHG)? 0x80: 0;
112	};
113	panic("sun_82072_fd_inb: How did I get here?");
114}
115
116static void sun_82072_fd_outb(unsigned char value, int port)
117{
118	udelay(5);
119	switch(port & 7) {
120	default:
121		printk("floppy: Asked to write to unknown port %d\n", port);
122		panic("floppy: Port bolixed.");
123	case 2: /* FD_DOR */
124		/* Oh geese, 82072 on the Sun has no DOR register,
125		 * the functionality is implemented via the AUXIO
126		 * I/O register.  So we must emulate the behavior.
127		 *
128		 * ASSUMPTIONS:  There will only ever be one floppy
129		 *               drive attached to a Sun controller
130		 *               and it will be at drive zero.
131		 */
132		{
133			unsigned bits = 0;
134			if (value & 0x10) bits |= AUXIO_FLPY_DSEL;
135			if ((value & 0x80) == 0) bits |= AUXIO_FLPY_EJCT;
136			set_auxio(bits, (~bits) & (AUXIO_FLPY_DSEL|AUXIO_FLPY_EJCT));
137		}
138		break;
139	case 5: /* FD_DATA */
140		sun_fdc->data_82072 = value;
141		break;
142	case 7: /* FD_DCR */
143		sun_fdc->dcr_82072 = value;
144		break;
145	case 4: /* FD_STATUS */
146		sun_fdc->status_82072 = value;
147		break;
148	};
149	return;
150}
151
152static unsigned char sun_82077_fd_inb(int port)
153{
154	udelay(5);
155	switch(port & 7) {
156	default:
157		printk("floppy: Asked to read unknown port %d\n", port);
158		panic("floppy: Port bolixed.");
159	case 4: /* FD_STATUS */
160		return sun_fdc->status_82077 & ~STATUS_DMA;
161	case 5: /* FD_DATA */
162		return sun_fdc->data_82077;
163	case 7: /* FD_DIR */
164		return sun_fdc->dir_82077;
165	};
166	panic("sun_82072_fd_inb: How did I get here?");
167}
168
169static void sun_82077_fd_outb(unsigned char value, int port)
170{
171	udelay(5);
172	switch(port & 7) {
173	default:
174		printk("floppy: Asked to write to unknown port %d\n", port);
175		panic("floppy: Port bolixed.");
176	case 2: /* FD_DOR */
177		/* Happily, the 82077 has a real DOR register. */
178		sun_fdc->dor_82077 = value;
179		break;
180	case 5: /* FD_DATA */
181		sun_fdc->data_82077 = value;
182		break;
183	case 7: /* FD_DCR */
184		sun_fdc->dcr_82077 = value;
185		break;
186	case 4: /* FD_STATUS */
187		sun_fdc->status_82077 = value;
188		break;
189	};
190	return;
191}
192
193/* For pseudo-dma (Sun floppy drives have no real DMA available to
194 * them so we must eat the data fifo bytes directly ourselves) we have
195 * three state variables.  doing_pdma tells our inline low-level
196 * assembly floppy interrupt entry point whether it should sit and eat
197 * bytes from the fifo or just transfer control up to the higher level
198 * floppy interrupt c-code.  I tried very hard but I could not get the
199 * pseudo-dma to work in c-code without getting many overruns and
200 * underruns.  If non-zero, doing_pdma encodes the direction of
201 * the transfer for debugging.  1=read 2=write
202 */
203char *pdma_vaddr;
204unsigned long pdma_size;
205volatile int doing_pdma = 0;
206
207/* This is software state */
208char *pdma_base = NULL;
209unsigned long pdma_areasize;
210
211/* Common routines to all controller types on the Sparc. */
212static __inline__ void virtual_dma_init(void)
213{
214	/* nothing... */
215}
216
217static __inline__ void sun_fd_disable_dma(void)
218{
219	doing_pdma = 0;
220	if (pdma_base) {
221		mmu_unlockarea(pdma_base, pdma_areasize);
222		pdma_base = NULL;
223	}
224}
225
226static __inline__ void sun_fd_set_dma_mode(int mode)
227{
228	switch(mode) {
229	case DMA_MODE_READ:
230		doing_pdma = 1;
231		break;
232	case DMA_MODE_WRITE:
233		doing_pdma = 2;
234		break;
235	default:
236		printk("Unknown dma mode %d\n", mode);
237		panic("floppy: Giving up...");
238	}
239}
240
241static __inline__ void sun_fd_set_dma_addr(char *buffer)
242{
243	pdma_vaddr = buffer;
244}
245
246static __inline__ void sun_fd_set_dma_count(int length)
247{
248	pdma_size = length;
249}
250
251static __inline__ void sun_fd_enable_dma(void)
252{
253	pdma_vaddr = mmu_lockarea(pdma_vaddr, pdma_size);
254	pdma_base = pdma_vaddr;
255	pdma_areasize = pdma_size;
256}
257
258/* Our low-level entry point in arch/sparc/kernel/entry.S */
259irqreturn_t floppy_hardint(int irq, void *unused);
260
261static int sun_fd_request_irq(void)
262{
263	static int once = 0;
264	int error;
265
266	if(!once) {
267		once = 1;
268		error = request_fast_irq(FLOPPY_IRQ, floppy_hardint,
269					 IRQF_DISABLED, "floppy");
270		return ((error == 0) ? 0 : -1);
271	} else return 0;
272}
273
274static struct linux_prom_registers fd_regs[2];
275
276static int sun_floppy_init(void)
277{
278	char state[128];
279	int tnode, fd_node, num_regs;
280	struct resource r;
281
282	use_virtual_dma = 1;
283
284	FLOPPY_IRQ = 11;
285	/* Forget it if we aren't on a machine that could possibly
286	 * ever have a floppy drive.
287	 */
288	if((sparc_cpu_model != sun4c && sparc_cpu_model != sun4m) ||
289	   ((idprom->id_machtype == (SM_SUN4C | SM_4C_SLC)) ||
290	    (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC)))) {
291		/* We certainly don't have a floppy controller. */
292		goto no_sun_fdc;
293	}
294	/* Well, try to find one. */
295	tnode = prom_getchild(prom_root_node);
296	fd_node = prom_searchsiblings(tnode, "obio");
297	if(fd_node != 0) {
298		tnode = prom_getchild(fd_node);
299		fd_node = prom_searchsiblings(tnode, "SUNW,fdtwo");
300	} else {
301		fd_node = prom_searchsiblings(tnode, "fd");
302	}
303	if(fd_node == 0) {
304		goto no_sun_fdc;
305	}
306
307	/* The sun4m lets us know if the controller is actually usable. */
308	if(sparc_cpu_model == sun4m &&
309	   prom_getproperty(fd_node, "status", state, sizeof(state)) != -1) {
310		if(!strcmp(state, "disabled")) {
311			goto no_sun_fdc;
312		}
313	}
314	num_regs = prom_getproperty(fd_node, "reg", (char *) fd_regs, sizeof(fd_regs));
315	num_regs = (num_regs / sizeof(fd_regs[0]));
316	prom_apply_obio_ranges(fd_regs, num_regs);
317	memset(&r, 0, sizeof(r));
318	r.flags = fd_regs[0].which_io;
319	r.start = fd_regs[0].phys_addr;
320	sun_fdc = (struct sun_flpy_controller *)
321	    sbus_ioremap(&r, 0, fd_regs[0].reg_size, "floppy");
322
323	/* Last minute sanity check... */
324	if(sun_fdc->status_82072 == 0xff) {
325		sun_fdc = NULL;
326		goto no_sun_fdc;
327	}
328
329        if(sparc_cpu_model == sun4c) {
330                sun_fdops.fd_inb = sun_82072_fd_inb;
331                sun_fdops.fd_outb = sun_82072_fd_outb;
332                fdc_status = &sun_fdc->status_82072;
333                /* printk("AUXIO @0x%lx\n", auxio_register); */ /* P3 */
334        } else {
335                sun_fdops.fd_inb = sun_82077_fd_inb;
336                sun_fdops.fd_outb = sun_82077_fd_outb;
337                fdc_status = &sun_fdc->status_82077;
338                /* printk("DOR @0x%p\n", &sun_fdc->dor_82077); */ /* P3 */
339	}
340
341	/* Success... */
342	allowed_drive_mask = 0x01;
343	return (int) sun_fdc;
344
345no_sun_fdc:
346	return -1;
347}
348
349static int sparc_eject(void)
350{
351	set_dor(0x00, 0xff, 0x90);
352	udelay(500);
353	set_dor(0x00, 0x6f, 0x00);
354	udelay(500);
355	return 0;
356}
357
358#define fd_eject(drive) sparc_eject()
359
360#define EXTRA_FLOPPY_PARAMS
361
362#endif /* !(__ASM_SPARC_FLOPPY_H) */
363