floppy_32.h

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