xref: /netbsd-src/sys/arch/acorn32/podulebus/simide.c (revision 8b0f9554ff8762542c4defc4f70e1eb76fb508fa)
1 /*	$NetBSD: simide.c,v 1.24 2006/09/24 23:14:58 bjh21 Exp $	*/
2 
3 /*
4  * Copyright (c) 1997-1998 Mark Brinicombe
5  * Copyright (c) 1997-1998 Causality Limited
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. All advertising materials mentioning features or use of this software
16  *    must display the following acknowledgement:
17  *	This product includes software developed by Mark Brinicombe
18  *	for the NetBSD Project.
19  * 4. The name of the author may not be used to endorse or promote products
20  *    derived from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Card driver and probe and attach functions to use generic IDE driver
34  * for the Simtec IDE podule
35  */
36 
37 /*
38  * Thanks to Gareth Simpson, Simtec Electronics for providing
39  * the hardware information
40  */
41 
42 #include <sys/cdefs.h>
43 __KERNEL_RCSID(0, "$NetBSD: simide.c,v 1.24 2006/09/24 23:14:58 bjh21 Exp $");
44 
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/conf.h>
48 #include <sys/device.h>
49 #include <sys/malloc.h>
50 
51 #include <machine/intr.h>
52 #include <machine/io.h>
53 #include <machine/bus.h>
54 #include <acorn32/podulebus/podulebus.h>
55 #include <acorn32/podulebus/simidereg.h>
56 
57 #include <dev/ata/atavar.h>
58 #include <dev/ic/wdcreg.h>
59 #include <dev/ic/wdcvar.h>
60 #include <dev/podulebus/podules.h>
61 
62 
63 /*
64  * Simtec IDE podule device.
65  *
66  * This probes and attaches the top level Simtec IDE device to the podulebus.
67  * It then configures any children of the Simtec IDE device.
68  * The attach args specify whether it is configuring the primary or
69  * secondary channel.
70  * The children are expected to be wdc devices using simide attachments.
71  */
72 
73 /*
74  * Simtec IDE card softc structure.
75  *
76  * Contains the device node, podule information and global information
77  * required by the driver such as the card version and the interrupt mask.
78  */
79 
80 struct simide_softc {
81 	struct wdc_softc	sc_wdcdev;	/* common wdc definitions */
82 	struct ata_channel	*sc_chanarray[2]; /* channels definition */
83 	podule_t 		*sc_podule;		/* Our podule info */
84 	int 			sc_podule_number;	/* Our podule number */
85 	int			sc_ctl_reg;		/* Global ctl reg */
86 	int			sc_version;		/* Card version */
87 	bus_space_tag_t		sc_ctliot;		/* Bus tag */
88 	bus_space_handle_t	sc_ctlioh;		/* control handle */
89 	struct bus_space 	sc_tag;			/* custom tag */
90 	struct simide_channel {
91 		struct ata_channel sc_channel;	/* generic part */
92 		struct ata_queue sc_chqueue;		/* channel queue */
93 		irqhandler_t	sc_ih;			/* interrupt handler */
94 		int		sc_irqmask;	/* IRQ mask for this channel */
95 	} simide_channels[2];
96 	struct wdc_regs sc_wdc_regs[2];
97 };
98 
99 int	simide_probe	__P((struct device *, struct cfdata *, void *));
100 void	simide_attach	__P((struct device *, struct device *, void *));
101 void	simide_shutdown	__P((void *arg));
102 int	simide_intr	__P((void *arg));
103 
104 CFATTACH_DECL(simide, sizeof(struct simide_softc),
105     simide_probe, simide_attach, NULL, NULL);
106 
107 
108 /*
109  * Define prototypes for custom bus space functions.
110  */
111 
112 bs_rm_2_proto(simide);
113 bs_wm_2_proto(simide);
114 
115 /*
116  * Create an array of address structures. These define the addresses and
117  * masks needed for the different channels.
118  *
119  * index = channel
120  */
121 
122 struct {
123 	u_int drive_registers;
124 	u_int aux_register;
125 	u_int irq_mask;
126 } simide_info[] = {
127 	{ PRIMARY_DRIVE_REGISTERS_POFFSET, PRIMARY_AUX_REGISTER_POFFSET,
128 	  CONTROL_PRIMARY_IRQ },
129 	{ SECONDARY_DRIVE_REGISTERS_POFFSET, SECONDARY_AUX_REGISTER_POFFSET,
130 	  CONTROL_SECONDARY_IRQ }
131 };
132 
133 /*
134  * Card probe function
135  *
136  * Just match the manufacturer and podule ID's
137  */
138 
139 int
140 simide_probe(parent, cf, aux)
141 	struct device *parent;
142 	struct cfdata *cf;
143 	void *aux;
144 {
145 	struct podule_attach_args *pa = (void *)aux;
146 
147 	return (pa->pa_product == PODULE_SIMTEC_IDE);
148 }
149 
150 /*
151  * Card attach function
152  *
153  * Identify the card version and configure any children.
154  * Install a shutdown handler to kill interrupts on shutdown
155  */
156 
157 void
158 simide_attach(parent, self, aux)
159 	struct device *parent, *self;
160 	void *aux;
161 {
162 	struct simide_softc *sc = (void *)self;
163 	struct podule_attach_args *pa = (void *)aux;
164 	int status;
165 	u_int iobase;
166 	int channel, i;
167 	struct simide_channel *scp;
168 	struct ata_channel *cp;
169 	struct wdc_regs *wdr;
170 	irqhandler_t *ihp;
171 
172 	/* Note the podule number and validate */
173 	if (pa->pa_podule_number == -1)
174 		panic("Podule has disappeared !");
175 
176 	sc->sc_podule_number = pa->pa_podule_number;
177 	sc->sc_podule = pa->pa_podule;
178 	podules[sc->sc_podule_number].attached = 1;
179 
180 	sc->sc_wdcdev.regs = sc->sc_wdc_regs;
181 
182 	/*
183 	 * Ok we need our own bus tag as the register spacing
184 	 * is not the default.
185 	 *
186 	 * For the podulebus the bus tag cookie is the shift
187 	 * to apply to registers
188 	 * So duplicate the bus space tag and change the
189 	 * cookie.
190 	 *
191 	 * Also while we are at it replace the default
192 	 * read/write mulitple short functions with
193 	 * optimised versions
194 	 */
195 
196 	sc->sc_tag = *pa->pa_iot;
197 	sc->sc_tag.bs_cookie = (void *) DRIVE_REGISTER_SPACING_SHIFT;
198 	sc->sc_tag.bs_rm_2 = simide_bs_rm_2;
199 	sc->sc_tag.bs_wm_2 = simide_bs_wm_2;
200 	sc->sc_ctliot = pa->pa_iot;
201 
202 	/* Obtain bus space handles for all the control registers */
203 	if (bus_space_map(sc->sc_ctliot, pa->pa_podule->mod_base +
204 	    CONTROL_REGISTERS_POFFSET, CONTROL_REGISTER_SPACE, 0,
205 	    &sc->sc_ctlioh))
206 		panic("%s: Cannot map control registers", self->dv_xname);
207 
208 	/* Install a clean up handler to make sure IRQ's are disabled */
209 	if (shutdownhook_establish(simide_shutdown, (void *)sc) == NULL)
210 		panic("%s: Cannot install shutdown handler", self->dv_xname);
211 
212 	/* Set the interrupt info for this podule */
213 	sc->sc_podule->irq_addr = pa->pa_podule->mod_base
214 	    + CONTROL_REGISTERS_POFFSET + (CONTROL_REGISTER_OFFSET << 2);
215 	sc->sc_podule->irq_mask = STATUS_IRQ;
216 
217 	sc->sc_ctl_reg = 0;
218 
219 	status = bus_space_read_1(sc->sc_ctliot, sc->sc_ctlioh,
220 	    STATUS_REGISTER_OFFSET);
221 
222 	printf(":");
223 	/* If any of the bits in STATUS_FAULT are zero then we have a fault. */
224 	if ((status & STATUS_FAULT) != STATUS_FAULT)
225 		printf(" card/cable fault (%02x) -", status);
226 
227 	if (!(status & STATUS_RESET))
228 		printf(" (reset)");
229 	if (!(status & STATUS_ADDR_TEST))
230 		printf(" (addr)");
231 	if (!(status & STATUS_CS_TEST))
232 		printf(" (cs)");
233 	if (!(status & STATUS_RW_TEST))
234 		printf(" (rw)");
235 
236 	printf("\n");
237 
238 	/* Perhaps we should just abort at this point. */
239 /*	if ((status & STATUS_FAULT) != STATUS_FAULT)
240 		return;*/
241 
242 	/*
243 	 * Enable IDE, Obey IORDY and disabled slow mode
244 	 */
245 	sc->sc_ctl_reg |= CONTROL_IDE_ENABLE | CONTROL_IORDY
246 			| CONTROL_SLOW_MODE_OFF;
247 	bus_space_write_1(sc->sc_ctliot, sc->sc_ctlioh,
248 	    CONTROL_REGISTER_OFFSET, sc->sc_ctl_reg);
249 
250 	/* Fill in wdc and channel infos */
251 	sc->sc_wdcdev.sc_atac.atac_cap |= ATAC_CAP_DATA16;
252 	sc->sc_wdcdev.sc_atac.atac_pio_cap = 0;
253 	sc->sc_wdcdev.sc_atac.atac_channels = sc->sc_chanarray;
254 	sc->sc_wdcdev.sc_atac.atac_nchannels = 2;
255 	for (channel = 0 ; channel < 2; channel++) {
256 		scp = &sc->simide_channels[channel];
257 		sc->sc_chanarray[channel] = &scp->sc_channel;
258 		cp = &scp->sc_channel;
259 		wdr = &sc->sc_wdc_regs[channel];
260 
261 		cp->ch_channel = channel;
262 		cp->ch_atac = &sc->sc_wdcdev.sc_atac;
263 		cp->ch_queue = &scp->sc_chqueue;
264 		cp->ch_ndrive = 2;
265 		wdr->cmd_iot = wdr->ctl_iot = &sc->sc_tag;
266 		iobase = pa->pa_podule->mod_base;
267 		if (bus_space_map(wdr->cmd_iot, iobase +
268 		    simide_info[channel].drive_registers,
269 		    DRIVE_REGISTERS_SPACE, 0, &wdr->cmd_baseioh))
270 			continue;
271 		for (i = 0; i < WDC_NREG; i++) {
272 			if (bus_space_subregion(wdr->cmd_iot, wdr->cmd_baseioh,
273 				i, i == 0 ? 4 : 1, &wdr->cmd_iohs[i]) != 0) {
274 				bus_space_unmap(wdr->cmd_iot, wdr->cmd_baseioh,
275 				    DRIVE_REGISTERS_SPACE);
276 				continue;
277 			}
278 		}
279 		wdc_init_shadow_regs(cp);
280 		if (bus_space_map(wdr->ctl_iot, iobase +
281 		    simide_info[channel].aux_register, 4, 0, &wdr->ctl_ioh)) {
282 			bus_space_unmap(wdr->cmd_iot, wdr->cmd_baseioh,
283 			    DRIVE_REGISTERS_SPACE);
284 			continue;
285 		}
286 		/* Disable interrupts and clear any pending interrupts */
287 		scp->sc_irqmask = simide_info[channel].irq_mask;
288 		sc->sc_ctl_reg &= ~scp->sc_irqmask;
289 		bus_space_write_1(sc->sc_ctliot, sc->sc_ctlioh,
290 		    CONTROL_REGISTER_OFFSET, sc->sc_ctl_reg);
291 		ihp = &scp->sc_ih;
292 		ihp->ih_func = simide_intr;
293 		ihp->ih_arg = scp;
294 		ihp->ih_level = IPL_BIO;
295 		ihp->ih_name = "simide";
296 		ihp->ih_maskaddr = pa->pa_podule->irq_addr;
297 		ihp->ih_maskbits = scp->sc_irqmask;
298 		if (irq_claim(sc->sc_podule->interrupt, ihp))
299 			panic("%s: Cannot claim interrupt %d",
300 			    self->dv_xname, sc->sc_podule->interrupt);
301 		/* clear any pending interrupts and enable interrupts */
302 		sc->sc_ctl_reg |= scp->sc_irqmask;
303 		bus_space_write_1(sc->sc_ctliot, sc->sc_ctlioh,
304 		    CONTROL_REGISTER_OFFSET, sc->sc_ctl_reg);
305 		wdcattach(cp);
306 	}
307 }
308 
309 /*
310  * Card shutdown function
311  *
312  * Called via do_shutdown_hooks() during kernel shutdown.
313  * Clear the cards's interrupt mask to stop any podule interrupts.
314  */
315 
316 void
317 simide_shutdown(arg)
318 	void *arg;
319 {
320 	struct simide_softc *sc = arg;
321 
322 	sc->sc_ctl_reg &= (CONTROL_PRIMARY_IRQ | CONTROL_SECONDARY_IRQ);
323 
324 	/* Disable card interrupts */
325 	bus_space_write_1(sc->sc_ctliot, sc->sc_ctlioh,
326 	    CONTROL_REGISTER_OFFSET, sc->sc_ctl_reg);
327 }
328 
329 /*
330  * Podule interrupt handler
331  *
332  * If the interrupt was from our card pass it on to the wdc interrupt handler
333  */
334 int
335 simide_intr(arg)
336 	void *arg;
337 {
338 	struct simide_channel *scp = arg;
339 	irqhandler_t *ihp = &scp->sc_ih;
340 	volatile u_char *intraddr = (volatile u_char *)ihp->ih_maskaddr;
341 
342 	/* XXX - not bus space yet - should really be handled by podulebus */
343 	if ((*intraddr) & ihp->ih_maskbits)
344 		wdcintr(&scp->sc_channel);
345 
346 	return(0);
347 }
348