asc_vsbus.c revision 1.13
1 /* $NetBSD: asc_vsbus.c,v 1.13 2000/05/17 21:22:20 matt Exp $ */ 2 3 /*- 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Charles M. Hannum. 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 #include "opt_vax46.h" 40 41 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */ 42 43 __KERNEL_RCSID(0, "$NetBSD: asc_vsbus.c,v 1.13 2000/05/17 21:22:20 matt Exp $"); 44 45 #include <sys/types.h> 46 #include <sys/param.h> 47 #include <sys/systm.h> 48 #include <sys/kernel.h> 49 #include <sys/errno.h> 50 #include <sys/ioctl.h> 51 #include <sys/device.h> 52 #include <sys/buf.h> 53 #include <sys/proc.h> 54 #include <sys/user.h> 55 #include <sys/reboot.h> 56 #include <sys/queue.h> 57 58 #include <dev/scsipi/scsi_all.h> 59 #include <dev/scsipi/scsipi_all.h> 60 #include <dev/scsipi/scsiconf.h> 61 #include <dev/scsipi/scsi_message.h> 62 63 #include <machine/bus.h> 64 #include <machine/vmparam.h> 65 66 #include <dev/ic/ncr53c9xreg.h> 67 #include <dev/ic/ncr53c9xvar.h> 68 69 #include <machine/cpu.h> 70 #include <machine/sid.h> 71 #include <machine/scb.h> 72 #include <machine/vsbus.h> 73 #include <machine/clock.h> /* for SCSI ctlr ID# XXX */ 74 75 struct asc_vsbus_softc { 76 struct ncr53c9x_softc sc_ncr53c9x; /* Must be first */ 77 bus_space_tag_t sc_bst; /* bus space tag */ 78 bus_space_handle_t sc_bsh; /* bus space handle */ 79 bus_space_handle_t sc_dirh; /* scsi direction handle */ 80 bus_space_handle_t sc_adrh; /* scsi address handle */ 81 bus_space_handle_t sc_ncrh; /* ncr bus space handle */ 82 bus_dma_tag_t sc_dmat; /* bus dma tag */ 83 bus_dmamap_t sc_dmamap; 84 caddr_t *sc_dmaaddr; 85 size_t *sc_dmalen; 86 size_t sc_dmasize; 87 unsigned int sc_flags; 88 #define ASC_FROMMEMORY 0x0001 /* Must be 1 */ 89 #define ASC_DMAACTIVE 0x0002 90 #define ASC_MAPLOADED 0x0004 91 unsigned long sc_xfers; 92 }; 93 94 #define ASC_REG_KA46_ADR 0x0000 95 #define ASC_REG_KA46_DIR 0x000C 96 #define ASC_REG_KA49_ADR 0x0000 97 #define ASC_REG_KA49_DIR 0x0004 98 #define ASC_REG_NCR 0x0080 99 #define ASC_REG_END 0x00B0 100 101 #define ASC_MAXXFERSIZE 65536 102 #define ASC_FREQUENCY 25000000 103 104 static int asc_vsbus_match __P((struct device *, struct cfdata *, void *)); 105 static void asc_vsbus_attach __P((struct device *, struct device *, void *)); 106 107 struct cfattach asc_vsbus_ca = { 108 sizeof(struct asc_vsbus_softc), asc_vsbus_match, asc_vsbus_attach 109 }; 110 111 static struct scsipi_device asc_vsbus_dev = { 112 NULL, /* Use the default error handler */ 113 NULL, /* have a queue, served by this */ 114 NULL, /* have no async handler */ 115 NULL, /* use the default done handler */ 116 }; 117 118 /* 119 * Functions and the switch for the MI code 120 */ 121 static u_char asc_vsbus_read_reg __P((struct ncr53c9x_softc *, int)); 122 static void asc_vsbus_write_reg __P((struct ncr53c9x_softc *, int, u_char)); 123 static int asc_vsbus_dma_isintr __P((struct ncr53c9x_softc *)); 124 static void asc_vsbus_dma_reset __P((struct ncr53c9x_softc *)); 125 static int asc_vsbus_dma_intr __P((struct ncr53c9x_softc *)); 126 static int asc_vsbus_dma_setup __P((struct ncr53c9x_softc *, caddr_t *, 127 size_t *, int, size_t *)); 128 static void asc_vsbus_dma_go __P((struct ncr53c9x_softc *)); 129 static void asc_vsbus_dma_stop __P((struct ncr53c9x_softc *)); 130 static int asc_vsbus_dma_isactive __P((struct ncr53c9x_softc *)); 131 132 static struct ncr53c9x_glue asc_vsbus_glue = { 133 asc_vsbus_read_reg, 134 asc_vsbus_write_reg, 135 asc_vsbus_dma_isintr, 136 asc_vsbus_dma_reset, 137 asc_vsbus_dma_intr, 138 asc_vsbus_dma_setup, 139 asc_vsbus_dma_go, 140 asc_vsbus_dma_stop, 141 asc_vsbus_dma_isactive, 142 NULL, 143 }; 144 145 static u_int8_t asc_attached; /* can't have more than one asc */ 146 147 static int 148 asc_vsbus_match( struct device *parent, struct cfdata *cf, void *aux) 149 { 150 struct vsbus_attach_args *va = aux; 151 volatile u_int8_t *ncr_regs; 152 int dummy; 153 154 if (asc_attached) 155 return 0; 156 157 if (vax_boardtype != VAX_BTYP_46 158 && vax_boardtype != VAX_BTYP_48 159 && vax_boardtype != VAX_BTYP_49) 160 return 0; 161 162 if (vax_boardtype == VAX_BTYP_49 && cf->cf_loc[0] != 0x26000080) 163 return 0; 164 165 if ((vax_boardtype == VAX_BTYP_46 || vax_boardtype == VAX_BTYP_48) 166 && cf->cf_loc[0] != 0x200c0080) 167 return 0; 168 169 ncr_regs = (volatile u_int8_t *) va->va_addr; 170 171 /* *** need to generate an interrupt here 172 * From trial and error, I've determined that an INT is generated 173 * only when the following sequence of events occurs: 174 * 1) The interrupt status register (0x05) must be read. 175 * 2) SCSI bus reset interrupt must be enabled 176 * 3) SCSI bus reset command must be sent 177 * 4) NOP command must be sent 178 */ 179 180 dummy = ncr_regs[NCR_INTR << 2] & 0xFF; 181 ncr_regs[NCR_CFG1 << 2] = 0x06; /* we're ID 6, turn on INT for SCSI reset */ 182 ncr_regs[NCR_CMD << 2] = NCRCMD_RSTSCSI; /* send the reset */ 183 ncr_regs[NCR_CMD << 2] = NCRCMD_NOP; /* send a NOP */ 184 DELAY(10000); 185 186 dummy = ncr_regs[NCR_INTR << 2] & 0xFF; 187 printf("ncr intr = %d\n", dummy); 188 return (dummy & NCRINTR_SBR) != 0; 189 } 190 191 192 /* 193 * Attach this instance, and then all the sub-devices 194 */ 195 static void 196 asc_vsbus_attach(struct device *parent, struct device *self, void *aux) 197 { 198 struct vsbus_attach_args *va = aux; 199 struct asc_vsbus_softc *asc = (void *)self; 200 struct ncr53c9x_softc *sc = &asc->sc_ncr53c9x; 201 int error; 202 203 asc_attached = 1; 204 /* 205 * Set up glue for MI code early; we use some of it here. 206 */ 207 sc->sc_glue = &asc_vsbus_glue; 208 209 asc->sc_bst = va->va_iot; 210 asc->sc_dmat = va->va_dmat; 211 212 error = bus_space_map(asc->sc_bst, va->va_paddr - ASC_REG_NCR, 213 ASC_REG_END, 0, &asc->sc_bsh); 214 if (error) { 215 printf(": failed to map registers: error=%d\n", error); 216 return; 217 } 218 error = bus_space_subregion(asc->sc_bst, asc->sc_bsh, ASC_REG_NCR, 219 ASC_REG_END - ASC_REG_NCR, &asc->sc_ncrh); 220 if (error) { 221 printf(": failed to map ncr registers: error=%d\n", error); 222 return; 223 } 224 if (vax_boardtype == VAX_BTYP_46 || vax_boardtype == VAX_BTYP_48) { 225 error = bus_space_subregion(asc->sc_bst, asc->sc_bsh, 226 ASC_REG_KA46_ADR, sizeof(u_int32_t), &asc->sc_adrh); 227 if (error) { 228 printf(": failed to map adr register: error=%d\n", 229 error); 230 return; 231 } 232 error = bus_space_subregion(asc->sc_bst, asc->sc_bsh, 233 ASC_REG_KA46_DIR, sizeof(u_int32_t), &asc->sc_dirh); 234 if (error) { 235 printf(": failed to map dir register: error=%d\n", 236 error); 237 return; 238 } 239 } else { 240 /* This is a gross and disgusting kludge but it'll 241 * save a bunch of ugly code. Unlike the VS4000/60, 242 * the SCSI Address and direction registers are not 243 * near the SCSI NCR registers and are inside the 244 * block of general VAXstation registers. So we grab 245 * them from there and knowing the internals of the 246 * bus_space implementation, we cast to bus_space_handles. 247 */ 248 struct vsbus_softc *vsc = (struct vsbus_softc *) parent; 249 asc->sc_adrh = (bus_space_handle_t) (vsc->sc_vsregs + ASC_REG_KA49_ADR); 250 asc->sc_dirh = (bus_space_handle_t) (vsc->sc_vsregs + ASC_REG_KA49_DIR); 251 } 252 error = bus_dmamap_create(asc->sc_dmat, ASC_MAXXFERSIZE, 1, 253 ASC_MAXXFERSIZE, 0, BUS_DMA_NOWAIT, &asc->sc_dmamap); 254 255 switch (vax_boardtype) { 256 #if defined(VAX46) 257 case VAX_BTYP_46: 258 sc->sc_id = (clk_page[0xbc/2] >> clk_tweak) & 7; 259 break; 260 #endif 261 default: 262 sc->sc_id = 6; /* XXX need to get this from VMB */ 263 break; 264 } 265 266 sc->sc_freq = ASC_FREQUENCY; 267 268 /* gimme Mhz */ 269 sc->sc_freq /= 1000000; 270 271 scb_vecalloc(va->va_cvec, (void (*)(void *)) ncr53c9x_intr, 272 &asc->sc_ncr53c9x, SCB_ISTACK); 273 274 /* 275 * XXX More of this should be in ncr53c9x_attach(), but 276 * XXX should we really poke around the chip that much in 277 * XXX the MI code? Think about this more... 278 */ 279 280 /* 281 * Set up static configuration info. 282 */ 283 sc->sc_cfg1 = sc->sc_id | NCRCFG1_PARENB; 284 sc->sc_cfg2 = NCRCFG2_SCSI2; 285 sc->sc_cfg3 = 0; 286 sc->sc_rev = NCR_VARIANT_NCR53C94; 287 288 /* 289 * XXX minsync and maxxfer _should_ be set up in MI code, 290 * XXX but it appears to have some dependency on what sort 291 * XXX of DMA we're hooked up to, etc. 292 */ 293 294 /* 295 * This is the value used to start sync negotiations 296 * Note that the NCR register "SYNCTP" is programmed 297 * in "clocks per byte", and has a minimum value of 4. 298 * The SCSI period used in negotiation is one-fourth 299 * of the time (in nanoseconds) needed to transfer one byte. 300 * Since the chip's clock is given in MHz, we have the following 301 * formula: 4 * period = (1000 / freq) * 4 302 */ 303 sc->sc_minsync = (1000 / sc->sc_freq); 304 sc->sc_maxxfer = 63 * 1024; 305 306 printf("\n%s", self->dv_xname); /* Pretty print */ 307 308 /* Do the common parts of attachment. */ 309 sc->sc_adapter.scsipi_cmd = ncr53c9x_scsi_cmd; 310 sc->sc_adapter.scsipi_minphys = minphys; 311 ncr53c9x_attach(sc, &asc_vsbus_dev); 312 } 313 314 /* 315 * Glue functions. 316 */ 317 318 static u_char 319 asc_vsbus_read_reg(struct ncr53c9x_softc *sc, int reg) 320 { 321 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 322 323 return bus_space_read_1(asc->sc_bst, asc->sc_ncrh, 324 reg * sizeof(u_int32_t)); 325 } 326 327 static void 328 asc_vsbus_write_reg(sc, reg, val) 329 struct ncr53c9x_softc *sc; 330 int reg; 331 u_char val; 332 { 333 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 334 335 bus_space_write_1(asc->sc_bst, asc->sc_ncrh, 336 reg * sizeof(u_int32_t), val); 337 } 338 339 static int 340 asc_vsbus_dma_isintr(sc) 341 struct ncr53c9x_softc *sc; 342 { 343 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 344 return bus_space_read_1(asc->sc_bst, asc->sc_ncrh, 345 NCR_STAT * sizeof(u_int32_t)) & NCRSTAT_INT; 346 } 347 348 static void 349 asc_vsbus_dma_reset(sc) 350 struct ncr53c9x_softc *sc; 351 { 352 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 353 354 if (asc->sc_flags & ASC_MAPLOADED) 355 bus_dmamap_unload(asc->sc_dmat, asc->sc_dmamap); 356 asc->sc_flags &= ~(ASC_DMAACTIVE|ASC_MAPLOADED); 357 } 358 359 static int 360 asc_vsbus_dma_intr(sc) 361 struct ncr53c9x_softc *sc; 362 { 363 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 364 u_int tcl, tcm; 365 int trans, resid; 366 367 if ((asc->sc_flags & ASC_DMAACTIVE) == 0) 368 panic("asc_vsbus_dma_intr: DMA wasn't active"); 369 370 asc->sc_flags &= ~ASC_DMAACTIVE; 371 372 if (asc->sc_dmasize == 0) { 373 /* A "Transfer Pad" operation completed */ 374 tcl = NCR_READ_REG(sc, NCR_TCL); 375 tcm = NCR_READ_REG(sc, NCR_TCM); 376 NCR_DMA(("asc_vsbus_intr: discarded %d bytes (tcl=%d, tcm=%d)\n", 377 tcl | (tcm << 8), tcl, tcm)); 378 return 0; 379 } 380 381 resid = 0; 382 if ((resid = (NCR_READ_REG(sc, NCR_FFLAG) & NCRFIFO_FF)) != 0) { 383 NCR_DMA(("asc_vsbus_intr: empty FIFO of %d ", resid)); 384 DELAY(1); 385 } 386 if (asc->sc_flags & ASC_MAPLOADED) { 387 bus_dmamap_sync(asc->sc_dmat, asc->sc_dmamap, 388 0, asc->sc_dmasize, 389 asc->sc_flags & ASC_FROMMEMORY 390 ? BUS_DMASYNC_POSTWRITE 391 : BUS_DMASYNC_POSTREAD); 392 bus_dmamap_unload(asc->sc_dmat, asc->sc_dmamap); 393 } 394 asc->sc_flags &= ~ASC_MAPLOADED; 395 396 resid += (tcl = NCR_READ_REG(sc, NCR_TCL)); 397 resid += (tcm = NCR_READ_REG(sc, NCR_TCM)) << 8; 398 399 trans = asc->sc_dmasize - resid; 400 if (trans < 0) { /* transferred < 0 ? */ 401 printf("asc_vsbus_intr: xfer (%d) > req (%d)\n", 402 trans, asc->sc_dmasize); 403 trans = asc->sc_dmasize; 404 } 405 NCR_DMA(("asc_vsbus_intr: tcl=%d, tcm=%d; trans=%d, resid=%d\n", 406 tcl, tcm, trans, resid)); 407 408 *asc->sc_dmalen -= trans; 409 *asc->sc_dmaaddr += trans; 410 411 asc->sc_xfers++; 412 return 0; 413 } 414 415 static int 416 asc_vsbus_dma_setup(struct ncr53c9x_softc *sc, caddr_t *addr, size_t *len, 417 int datain, size_t *dmasize) 418 { 419 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 420 421 asc->sc_dmaaddr = addr; 422 asc->sc_dmalen = len; 423 if (datain) { 424 asc->sc_flags &= ~ASC_FROMMEMORY; 425 } else { 426 asc->sc_flags |= ASC_FROMMEMORY; 427 } 428 if ((vaddr_t) *asc->sc_dmaaddr < VM_MIN_KERNEL_ADDRESS) 429 panic("asc_vsbus_dma_setup: dma address (%p) outside of kernel", 430 *asc->sc_dmaaddr); 431 432 NCR_DMA(("%s: start %d@%p,%d\n", sc->sc_dev.dv_xname, 433 (int)*asc->sc_dmalen, *asc->sc_dmaaddr, (asc->sc_flags & ASC_FROMMEMORY))); 434 *dmasize = asc->sc_dmasize = min(*dmasize, ASC_MAXXFERSIZE); 435 436 if (asc->sc_dmasize) { 437 if (bus_dmamap_load(asc->sc_dmat, asc->sc_dmamap, 438 *asc->sc_dmaaddr, asc->sc_dmasize, 439 NULL /* kernel address */, 440 BUS_DMA_NOWAIT|VAX_BUS_DMA_SPILLPAGE)) 441 panic("%s: cannot load dma map", sc->sc_dev.dv_xname); 442 bus_dmamap_sync(asc->sc_dmat, asc->sc_dmamap, 443 0, asc->sc_dmasize, 444 asc->sc_flags & ASC_FROMMEMORY 445 ? BUS_DMASYNC_PREWRITE 446 : BUS_DMASYNC_PREREAD); 447 bus_space_write_4(asc->sc_bst, asc->sc_adrh, 0, 448 asc->sc_dmamap->dm_segs[0].ds_addr); 449 bus_space_write_4(asc->sc_bst, asc->sc_dirh, 0, 450 asc->sc_flags & ASC_FROMMEMORY); 451 asc->sc_flags |= ASC_MAPLOADED; 452 } 453 454 return 0; 455 } 456 457 static void 458 asc_vsbus_dma_go(struct ncr53c9x_softc *sc) 459 { 460 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 461 462 asc->sc_flags |= ASC_DMAACTIVE; 463 } 464 465 static void 466 asc_vsbus_dma_stop(struct ncr53c9x_softc *sc) 467 { 468 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 469 470 if (asc->sc_flags & ASC_MAPLOADED) { 471 bus_dmamap_sync(asc->sc_dmat, asc->sc_dmamap, 472 0, asc->sc_dmasize, 473 asc->sc_flags & ASC_FROMMEMORY 474 ? BUS_DMASYNC_POSTWRITE 475 : BUS_DMASYNC_POSTREAD); 476 bus_dmamap_unload(asc->sc_dmat, asc->sc_dmamap); 477 } 478 479 asc->sc_flags &= ~(ASC_DMAACTIVE|ASC_MAPLOADED); 480 } 481 482 static int 483 asc_vsbus_dma_isactive(struct ncr53c9x_softc *sc) 484 { 485 struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; 486 487 return (asc->sc_flags & ASC_DMAACTIVE) != 0; 488 } 489
Indexes created Tue Sep 30 07:10:03 GMT 2025