kdb.c revision 1.17
1 /* $NetBSD: kdb.c,v 1.17 2000/03/26 11:45:04 ragge Exp $ */ 2 /* 3 * Copyright (c) 1996 Ludd, University of Lule}, Sweden. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed at Ludd, University of 17 * Lule}, Sweden and its contributors. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * KDB50 disk device driver 35 */ 36 /* 37 * TODO 38 * Implement node reset routine. 39 * Nices hardware error handling. 40 */ 41 42 #include <sys/param.h> 43 #include <sys/kernel.h> 44 #include <sys/buf.h> 45 #include <sys/device.h> 46 #include <sys/proc.h> 47 #include <sys/user.h> 48 #include <sys/malloc.h> 49 #include <sys/systm.h> 50 51 #include <vm/vm.h> 52 #include <vm/vm_kern.h> 53 54 #ifdef __vax__ 55 #include <machine/pte.h> 56 #include <machine/pcb.h> 57 #endif 58 #include <machine/bus.h> 59 60 #include <dev/bi/bireg.h> 61 #include <dev/bi/bivar.h> 62 #include <dev/bi/kdbreg.h> 63 64 #include <dev/mscp/mscp.h> 65 #include <dev/mscp/mscpreg.h> 66 #include <dev/mscp/mscpvar.h> 67 68 #include "locators.h" 69 70 #define KDB_WL(adr, val) bus_space_write_4(sc->sc_iot, sc->sc_ioh, adr, val) 71 #define KDB_RL(adr) bus_space_read_4(sc->sc_iot, sc->sc_ioh, adr) 72 #define KDB_RS(adr) bus_space_read_2(sc->sc_iot, sc->sc_ioh, adr) 73 74 #define b_forw b_hash.le_next 75 /* 76 * Software status, per controller. 77 */ 78 struct kdb_softc { 79 struct device sc_dev; /* Autoconfig info */ 80 caddr_t sc_kdb; /* Struct for kdb communication */ 81 struct mscp_softc *sc_softc; /* MSCP info (per mscpvar.h) */ 82 bus_dma_tag_t sc_dmat; 83 bus_dmamap_t sc_cmap; /* Control structures */ 84 bus_space_tag_t sc_iot; 85 bus_space_handle_t sc_ioh; 86 }; 87 88 int kdbmatch __P((struct device *, struct cfdata *, void *)); 89 void kdbattach __P((struct device *, struct device *, void *)); 90 void kdbreset __P((int)); 91 void kdbintr __P((void *)); 92 void kdbctlrdone __P((struct device *)); 93 int kdbprint __P((void *, const char *)); 94 void kdbsaerror __P((struct device *, int)); 95 void kdbgo __P((struct device *, struct mscp_xi *)); 96 97 struct cfattach kdb_ca = { 98 sizeof(struct kdb_softc), kdbmatch, kdbattach 99 }; 100 101 /* 102 * More driver definitions, for generic MSCP code. 103 */ 104 struct mscp_ctlr kdb_mscp_ctlr = { 105 kdbctlrdone, 106 kdbgo, 107 kdbsaerror, 108 }; 109 110 int 111 kdbprint(aux, name) 112 void *aux; 113 const char *name; 114 { 115 if (name) 116 printf("%s: mscpbus", name); 117 return UNCONF; 118 } 119 120 /* 121 * Poke at a supposed KDB to see if it is there. 122 */ 123 int 124 kdbmatch(parent, cf, aux) 125 struct device *parent; 126 struct cfdata *cf; 127 void *aux; 128 { 129 struct bi_attach_args *ba = aux; 130 131 if (bus_space_read_2(ba->ba_iot, ba->ba_ioh, BIREG_DTYPE) != BIDT_KDB50) 132 return 0; 133 134 if (cf->cf_loc[BICF_NODE] != BICF_NODE_DEFAULT && 135 cf->cf_loc[BICF_NODE] != ba->ba_nodenr) 136 return 0; 137 138 return 1; 139 } 140 141 void 142 kdbattach(parent, self, aux) 143 struct device *parent, *self; 144 void *aux; 145 { 146 struct kdb_softc *sc = (void *)self; 147 struct bi_attach_args *ba = aux; 148 struct mscp_attach_args ma; 149 volatile int i = 10000; 150 int error, rseg; 151 bus_dma_segment_t seg; 152 153 printf("\n"); 154 bi_intr_establish(ba->ba_icookie, ba->ba_ivec, kdbintr, sc); 155 156 sc->sc_iot = ba->ba_iot; 157 sc->sc_ioh = ba->ba_ioh; 158 sc->sc_dmat = ba->ba_dmat; 159 160 /* 161 * Map the communication area and command and 162 * response packets into Unibus space. 163 */ 164 if ((error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct mscp_pack), 165 NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) { 166 printf("Alloc ctrl area %d\n", error); 167 return; 168 } 169 if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, 170 sizeof(struct mscp_pack), &sc->sc_kdb, 171 BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) { 172 printf("Map ctrl area %d\n", error); 173 err: bus_dmamem_free(sc->sc_dmat, &seg, rseg); 174 return; 175 } 176 if ((error = bus_dmamap_create(sc->sc_dmat, sizeof(struct mscp_pack), 177 1, sizeof(struct mscp_pack), 0, BUS_DMA_NOWAIT, &sc->sc_cmap))) { 178 printf("Create DMA map %d\n", error); 179 err2: bus_dmamem_unmap(sc->sc_dmat, sc->sc_kdb, 180 sizeof(struct mscp_pack)); 181 goto err; 182 } 183 if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_cmap, 184 sc->sc_kdb, sizeof(struct mscp_pack), 0, BUS_DMA_NOWAIT))) { 185 printf("Load ctrl map %d\n", error); 186 bus_dmamap_destroy(sc->sc_dmat, sc->sc_cmap); 187 goto err2; 188 } 189 bzero(sc->sc_kdb, sizeof(struct mscp_pack)); 190 191 ma.ma_mc = &kdb_mscp_ctlr; 192 ma.ma_type = MSCPBUS_DISK|MSCPBUS_KDB; 193 ma.ma_uda = (struct mscp_pack *)sc->sc_kdb; 194 ma.ma_softc = &sc->sc_softc; 195 ma.ma_iot = sc->sc_iot; 196 ma.ma_iph = sc->sc_ioh + KDB_IP; 197 ma.ma_sah = sc->sc_ioh + KDB_SA; 198 ma.ma_swh = sc->sc_ioh + KDB_SW; 199 ma.ma_dmat = sc->sc_dmat; 200 ma.ma_dmam = sc->sc_cmap; 201 ma.ma_ivec = ba->ba_ivec; 202 ma.ma_ctlrnr = ba->ba_nodenr; 203 ma.ma_adapnr = ba->ba_busnr; 204 205 KDB_WL(BIREG_VAXBICSR, KDB_RL(BIREG_VAXBICSR) | BICSR_NRST); 206 while (i--) /* Need delay??? */ 207 ; 208 KDB_WL(BIREG_INTRDES, ba->ba_intcpu); /* Interrupt on CPU # */ 209 KDB_WL(BIREG_BCICSR, KDB_RL(BIREG_BCICSR) | 210 BCI_STOPEN | BCI_IDENTEN | BCI_UINTEN | BCI_INTEN); 211 KDB_WL(BIREG_UINTRCSR, ba->ba_ivec); 212 config_found(&sc->sc_dev, &ma, kdbprint); 213 } 214 215 void 216 kdbgo(usc, mxi) 217 struct device *usc; 218 struct mscp_xi *mxi; 219 { 220 struct kdb_softc *sc = (void *)usc; 221 struct buf *bp = mxi->mxi_bp; 222 struct mscp *mp = mxi->mxi_mp; 223 u_int32_t addr = (u_int32_t)bp->b_un.b_addr; 224 u_int32_t mapaddr; 225 int err; 226 227 /* 228 * The KDB50 wants to read VAX Page tables directly, therefore 229 * the result from bus_dmamap_load() is uninteresting. (But it 230 * should never fail!). 231 * 232 * On VAX, point to the corresponding page tables. (user/sys) 233 * On other systems, do something else... 234 */ 235 err = bus_dmamap_load(sc->sc_dmat, mxi->mxi_dmam, bp->b_un.b_addr, 236 bp->b_bcount, bp->b_proc, BUS_DMA_NOWAIT); 237 238 if (err) /* Shouldn't happen */ 239 panic("kdbgo: bus_dmamap_load: error %d", err); 240 241 #ifdef __vax__ 242 /* 243 * Get a pointer to the pte pointing out the first virtual address. 244 * Use different ways in kernel and user space. 245 */ 246 if ((bp->b_flags & B_PHYS) == 0) { 247 mapaddr = ((u_int32_t)kvtopte(addr)) & ~KERNBASE; 248 } else { 249 struct pcb *pcb; 250 u_int32_t eaddr; 251 252 /* 253 * We check if the PTE's needed crosses a page boundary. 254 * If they do; only transfer the amount of data that is 255 * mapped by the first PTE page and led the system handle 256 * the rest of the data. 257 */ 258 pcb = &bp->b_proc->p_addr->u_pcb; 259 mapaddr = (u_int32_t)uvtopte(addr, pcb); 260 eaddr = (u_int32_t)uvtopte(addr + (bp->b_bcount - 1), pcb); 261 if (trunc_page(mapaddr) != trunc_page(eaddr)) { 262 mp->mscp_seq.seq_bytecount = 263 (((round_page(mapaddr) - mapaddr)/4) * 512); 264 } 265 mapaddr = kvtophys(mapaddr); 266 } 267 #else 268 #error Must write code to handle KDB50 on non-vax. 269 #endif 270 271 mp->mscp_seq.seq_mapbase = mapaddr; 272 mxi->mxi_dmam->dm_segs[0].ds_addr = (addr & 511) | KDB_MAP; 273 mscp_dgo(sc->sc_softc, mxi); 274 } 275 276 void 277 kdbsaerror(usc, doreset) 278 struct device *usc; 279 int doreset; 280 { 281 struct kdb_softc *sc = (void *)usc; 282 283 if ((KDB_RS(KDB_SA) & MP_ERR) == 0) 284 return; 285 printf("%s: controller error, sa=0x%x\n", sc->sc_dev.dv_xname, 286 KDB_RS(KDB_SA)); 287 /* What to do now??? */ 288 } 289 290 /* 291 * Interrupt routine. Depending on the state of the controller, 292 * continue initialisation, or acknowledge command and response 293 * interrupts, and process responses. 294 */ 295 void 296 kdbintr(void *arg) 297 { 298 struct kdb_softc *sc = arg; 299 300 if (KDB_RS(KDB_SA) & MP_ERR) { /* ctlr fatal error */ 301 kdbsaerror(&sc->sc_dev, 1); 302 return; 303 } 304 mscp_intr(sc->sc_softc); 305 } 306 307 #ifdef notyet 308 /* 309 * The KDB50 has been reset. Reinitialise the controller 310 * and requeue outstanding I/O. 311 */ 312 void 313 kdbreset(ctlr) 314 int ctlr; 315 { 316 struct kdb_softc *sc; 317 318 sc = kdb_cd.cd_devs[ctlr]; 319 printf(" kdb%d", ctlr); 320 321 322 /* reset queues and requeue pending transfers */ 323 mscp_requeue(sc->sc_softc); 324 325 /* 326 * If it fails to initialise we will notice later and 327 * try again (and again...). Do not call kdbstart() 328 * here; it will be done after the controller finishes 329 * initialisation. 330 */ 331 if (kdbinit(sc)) 332 printf(" (hung)"); 333 } 334 #endif 335 336 void 337 kdbctlrdone(usc) 338 struct device *usc; 339 { 340 } 341
Indexes created Thu Sep 25 16:09:42 GMT 2025