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