vme_two.c revision 1.6
1 /* $NetBSD: vme_two.c,v 1.6 2007/10/19 12:00:37 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Steve C. Woodford. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * VME support specific to the VMEchip2 found on all high-end MVME boards 41 */ 42 43 #include <sys/cdefs.h> 44 __KERNEL_RCSID(0, "$NetBSD: vme_two.c,v 1.6 2007/10/19 12:00:37 ad Exp $"); 45 46 #include "vmetwo.h" 47 48 #include <sys/param.h> 49 #include <sys/kernel.h> 50 #include <sys/systm.h> 51 #include <sys/device.h> 52 53 #include <sys/cpu.h> 54 #include <sys/bus.h> 55 56 #include <dev/vme/vmereg.h> 57 #include <dev/vme/vmevar.h> 58 59 #include <dev/mvme/mvmebus.h> 60 #include <dev/mvme/vme_tworeg.h> 61 #include <dev/mvme/vme_twovar.h> 62 63 void vmetwo_master_range(struct vmetwo_softc *, int, struct mvmebus_range *); 64 void vmetwo_slave_range(struct vmetwo_softc *, int, vme_am_t, 65 struct mvmebus_range *); 66 67 /* ARGSUSED */ 68 void 69 vmetwo_init(sc) 70 struct vmetwo_softc *sc; 71 { 72 u_int32_t reg; 73 int i; 74 75 /* Initialise stuff for the common mvmebus front-end */ 76 sc->sc_mvmebus.sc_chip = sc; 77 sc->sc_mvmebus.sc_nmasters = VME2_NMASTERS; 78 sc->sc_mvmebus.sc_masters = &sc->sc_master[0]; 79 sc->sc_mvmebus.sc_nslaves = VME2_NSLAVES; 80 sc->sc_mvmebus.sc_slaves = &sc->sc_slave[0]; 81 sc->sc_mvmebus.sc_intr_establish = vmetwo_intr_establish; 82 sc->sc_mvmebus.sc_intr_disestablish = vmetwo_intr_disestablish; 83 84 /* Initialise interrupts */ 85 vmetwo_intr_init(sc); 86 87 reg = vme2_lcsr_read(sc, VME2LCSR_BOARD_CONTROL); 88 printf(": Type 2 VMEchip, scon jumper %s\n", 89 (reg & VME2_BOARD_CONTROL_SCON) ? "enabled" : "disabled"); 90 91 /* 92 * Figure out what bits of the VMEbus we can access. 93 * First record the `fixed' maps (if they're enabled) 94 */ 95 reg = vme2_lcsr_read(sc, VME2LCSR_IO_CONTROL); 96 if (reg & VME2_IO_CONTROL_I1EN) { 97 /* This range is fixed to A16, DATA */ 98 sc->sc_master[0].vr_am = VME_AM_A16 | MVMEBUS_AM_CAP_DATA; 99 100 /* However, SUPER/USER is selectable... */ 101 if (reg & VME2_IO_CONTROL_I1SU) 102 sc->sc_master[0].vr_am |= MVMEBUS_AM_CAP_SUPER; 103 else 104 sc->sc_master[0].vr_am |= MVMEBUS_AM_CAP_USER; 105 106 /* As is the datasize */ 107 sc->sc_master[0].vr_datasize = VME_D32 | VME_D16; 108 if (reg & VME2_IO_CONTROL_I1D16) 109 sc->sc_master[0].vr_datasize &= ~VME_D32; 110 111 sc->sc_master[0].vr_locstart = VME2_IO0_LOCAL_START; 112 sc->sc_master[0].vr_mask = VME2_IO0_MASK; 113 sc->sc_master[0].vr_vmestart = VME2_IO0_VME_START; 114 sc->sc_master[0].vr_vmeend = VME2_IO0_VME_END; 115 } else 116 sc->sc_master[0].vr_am = MVMEBUS_AM_DISABLED; 117 118 if (reg & VME2_IO_CONTROL_I2EN) { 119 /* These two ranges are fixed to A24D16 and A32D16 */ 120 sc->sc_master[1].vr_am = VME_AM_A24; 121 sc->sc_master[1].vr_datasize = VME_D16; 122 sc->sc_master[2].vr_am = VME_AM_A32; 123 sc->sc_master[2].vr_datasize = VME_D16; 124 125 /* However, SUPER/USER is selectable */ 126 if (reg & VME2_IO_CONTROL_I2SU) { 127 sc->sc_master[1].vr_am |= MVMEBUS_AM_CAP_SUPER; 128 sc->sc_master[2].vr_am |= MVMEBUS_AM_CAP_SUPER; 129 } else { 130 sc->sc_master[1].vr_am |= MVMEBUS_AM_CAP_USER; 131 sc->sc_master[2].vr_am |= MVMEBUS_AM_CAP_USER; 132 } 133 134 /* As is PROGRAM/DATA */ 135 if (reg & VME2_IO_CONTROL_I2PD) { 136 sc->sc_master[1].vr_am |= MVMEBUS_AM_CAP_PROG; 137 sc->sc_master[2].vr_am |= MVMEBUS_AM_CAP_PROG; 138 } else { 139 sc->sc_master[1].vr_am |= MVMEBUS_AM_CAP_DATA; 140 sc->sc_master[2].vr_am |= MVMEBUS_AM_CAP_DATA; 141 } 142 143 sc->sc_master[1].vr_locstart = VME2_IO1_LOCAL_START; 144 sc->sc_master[1].vr_mask = VME2_IO1_MASK; 145 sc->sc_master[1].vr_vmestart = VME2_IO1_VME_START; 146 sc->sc_master[1].vr_vmeend = VME2_IO1_VME_END; 147 148 sc->sc_master[2].vr_locstart = VME2_IO2_LOCAL_START; 149 sc->sc_master[2].vr_mask = VME2_IO2_MASK; 150 sc->sc_master[2].vr_vmestart = VME2_IO2_VME_START; 151 sc->sc_master[2].vr_vmeend = VME2_IO2_VME_END; 152 } else { 153 sc->sc_master[1].vr_am = MVMEBUS_AM_DISABLED; 154 sc->sc_master[2].vr_am = MVMEBUS_AM_DISABLED; 155 } 156 157 /* 158 * Now read the progammable maps 159 */ 160 for (i = 0; i < VME2_MASTER_WINDOWS; i++) 161 vmetwo_master_range(sc, i, 162 &(sc->sc_master[i + VME2_MASTER_PROG_START])); 163 164 /* XXX: No A16 slave yet :XXX */ 165 sc->sc_slave[VME2_SLAVE_A16].vr_am = MVMEBUS_AM_DISABLED; 166 167 for (i = 0; i < VME2_SLAVE_WINDOWS; i++) { 168 vmetwo_slave_range(sc, i, VME_AM_A32, 169 &sc->sc_slave[i + VME2_SLAVE_PROG_START]); 170 vmetwo_slave_range(sc, i, VME_AM_A24, 171 &sc->sc_slave[i + VME2_SLAVE_PROG_START + 2]); 172 } 173 174 mvmebus_attach(&sc->sc_mvmebus); 175 } 176 177 void 178 vmetwo_master_range(sc, range, vr) 179 struct vmetwo_softc *sc; 180 int range; 181 struct mvmebus_range *vr; 182 { 183 u_int32_t start, end, attr; 184 u_int32_t reg; 185 186 /* 187 * First, check if the range is actually enabled... 188 */ 189 reg = vme2_lcsr_read(sc, VME2LCSR_MASTER_ENABLE); 190 if ((reg & VME2_MASTER_ENABLE(range)) == 0) { 191 vr->vr_am = MVMEBUS_AM_DISABLED; 192 return; 193 } 194 195 /* 196 * Fetch and record the range's attributes 197 */ 198 attr = vme2_lcsr_read(sc, VME2LCSR_MASTER_ATTR); 199 attr >>= VME2_MASTER_ATTR_AM_SHIFT(range); 200 201 /* 202 * Fix up the datasizes available through this range 203 */ 204 vr->vr_datasize = VME_D32 | VME_D16; 205 if (attr & VME2_MASTER_ATTR_D16) 206 vr->vr_datasize &= ~VME_D32; 207 attr &= VME2_MASTER_ATTR_AM_MASK; 208 209 vr->vr_am = (attr & VME_AM_ADRSIZEMASK) | MVMEBUS_AM2CAP(attr); 210 switch (vr->vr_am & VME_AM_ADRSIZEMASK) { 211 case VME_AM_A32: 212 default: 213 vr->vr_mask = 0xffffffffu; 214 break; 215 216 case VME_AM_A24: 217 vr->vr_mask = 0x00ffffffu; 218 break; 219 220 case VME_AM_A16: 221 vr->vr_mask = 0x0000ffffu; 222 break; 223 } 224 225 /* 226 * XXX 227 * It would be nice if users of the MI VMEbus code could pass down 228 * whether they can tolerate Write-Posting to their device(s). 229 * XXX 230 */ 231 232 /* 233 * Fetch the local-bus start and end addresses for the range 234 */ 235 reg = vme2_lcsr_read(sc, VME2LCSR_MASTER_ADDRESS(range)); 236 start = (reg & VME2_MAST_ADDRESS_START_MASK); 237 start <<= VME2_MAST_ADDRESS_START_SHIFT; 238 vr->vr_locstart = start & ~vr->vr_mask; 239 end = (reg & VME2_MAST_ADDRESS_END_MASK); 240 end <<= VME2_MAST_ADDRESS_END_SHIFT; 241 end |= 0xffffu; 242 end += 1; 243 244 /* 245 * Local->VMEbus map '4' has optional translation bits, so 246 * the VMEbus start and end addresses may need to be adjusted. 247 */ 248 if (range == 3 && (reg = vme2_lcsr_read(sc, VME2LCSR_MAST4_TRANS))!=0) { 249 uint32_t addr, sel, len = end - start; 250 251 reg = vme2_lcsr_read(sc, VME2LCSR_MAST4_TRANS); 252 reg &= VME2_MAST4_TRANS_SELECT_MASK; 253 sel = reg << VME2_MAST4_TRANS_SELECT_SHIFT; 254 255 reg = vme2_lcsr_read(sc, VME2LCSR_MAST4_TRANS); 256 reg &= VME2_MAST4_TRANS_ADDRESS_MASK; 257 addr = reg << VME2_MAST4_TRANS_ADDRESS_SHIFT; 258 259 start = (addr & sel) | (start & (~sel)); 260 end = start + len; 261 vr->vr_mask &= len - 1; 262 } 263 264 /* XXX Deal with overlap of onboard RAM address space */ 265 /* XXX Then again, 167-Bug warns about this at setup time ... */ 266 267 /* 268 * Fixup the addresses this range corresponds to 269 */ 270 vr->vr_vmestart = start & vr->vr_mask; 271 vr->vr_vmeend = (end - 1) & vr->vr_mask; 272 } 273 274 void 275 vmetwo_slave_range(sc, range, am, vr) 276 struct vmetwo_softc *sc; 277 int range; 278 vme_am_t am; 279 struct mvmebus_range *vr; 280 { 281 u_int32_t reg; 282 283 /* 284 * First, check if the range is actually enabled. 285 * Note that bit 1 of `range' is used to indicte if we're 286 * looking for an A24 range (set) or an A32 range (clear). 287 */ 288 reg = vme2_lcsr_read(sc, VME2LCSR_SLAVE_CTRL); 289 290 if (am == VME_AM_A32 && (reg & VME2_SLAVE_AMSEL_A32(range))) { 291 vr->vr_am = VME_AM_A32; 292 vr->vr_mask = 0xffffffffu; 293 } else 294 if (am == VME_AM_A24 && (reg & VME2_SLAVE_AMSEL_A24(range))) { 295 vr->vr_am = VME_AM_A24; 296 vr->vr_mask = 0x00ffffffu; 297 } else { 298 /* The range is not enabled */ 299 vr->vr_am = MVMEBUS_AM_DISABLED; 300 return; 301 } 302 303 if ((reg & VME2_SLAVE_AMSEL_DAT(range)) != 0) 304 vr->vr_am |= MVMEBUS_AM_CAP_DATA; 305 306 if ((reg & VME2_SLAVE_AMSEL_PGM(range)) != 0) 307 vr->vr_am |= MVMEBUS_AM_CAP_PROG; 308 309 if ((reg & VME2_SLAVE_AMSEL_USR(range)) != 0) 310 vr->vr_am |= MVMEBUS_AM_CAP_USER; 311 312 if ((reg & VME2_SLAVE_AMSEL_SUP(range)) != 0) 313 vr->vr_am |= MVMEBUS_AM_CAP_SUPER; 314 315 if ((reg & VME2_SLAVE_AMSEL_BLK(range)) != 0) 316 vr->vr_am |= MVMEBUS_AM_CAP_BLK; 317 318 if ((reg & VME2_SLAVE_AMSEL_BLKD64(range)) != 0) 319 vr->vr_am |= MVMEBUS_AM_CAP_BLKD64; 320 321 vr->vr_datasize = VME_D32 | VME_D16 | VME_D8; 322 323 /* 324 * Record the VMEbus start and end addresses of the slave image 325 */ 326 reg = vme2_lcsr_read(sc, VME2LCSR_SLAVE_ADDRESS(range)); 327 vr->vr_vmestart = reg & VME2_SLAVE_ADDRESS_START_MASK; 328 vr->vr_vmestart <<= VME2_SLAVE_ADDRESS_START_SHIFT; 329 vr->vr_vmestart &= vr->vr_mask; 330 vr->vr_vmeend = reg & VME2_SLAVE_ADDRESS_END_MASK; 331 vr->vr_vmeend <<= VME2_SLAVE_ADDRESS_END_SHIFT; 332 vr->vr_vmeend &= vr->vr_mask; 333 vr->vr_vmeend |= 0xffffu; 334 335 /* 336 * Now figure out the local-bus address 337 */ 338 reg = vme2_lcsr_read(sc, VME2LCSR_SLAVE_CTRL); 339 if ((reg & VME2_SLAVE_CTRL_ADDER(range)) != 0) { 340 reg = vme2_lcsr_read(sc, VME2LCSR_SLAVE_TRANS(range)); 341 reg &= VME2_SLAVE_TRANS_ADDRESS_MASK; 342 reg <<= VME2_SLAVE_TRANS_ADDRESS_SHIFT; 343 vr->vr_locstart = vr->vr_vmestart + reg; 344 } else { 345 u_int32_t sel, addr; 346 347 reg = vme2_lcsr_read(sc, VME2LCSR_SLAVE_TRANS(range)); 348 sel = reg & VME2_SLAVE_TRANS_SELECT_MASK; 349 sel <<= VME2_SLAVE_TRANS_SELECT_SHIFT; 350 addr = reg & VME2_SLAVE_TRANS_ADDRESS_MASK; 351 addr <<= VME2_SLAVE_TRANS_ADDRESS_SHIFT; 352 353 vr->vr_locstart = addr & sel; 354 vr->vr_locstart |= vr->vr_vmestart & (~sel); 355 } 356 } 357
Indexes created Mon Sep 29 03:10:08 GMT 2025