Annotation of sys/arch/vax/bi/kdb.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: kdb.c,v 1.11 2007/05/11 10:06:55 pedro Exp $ */
2: /* $NetBSD: kdb.c,v 1.26 2001/11/13 12:51:34 lukem Exp $ */
3: /*
4: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
5: * All rights reserved.
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 at Ludd, University of
18: * Lule}, Sweden and its contributors.
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:
34: /*
35: * KDB50 disk device driver
36: */
37: /*
38: * TODO
39: * Implement node reset routine.
40: * Nices hardware error handling.
41: */
42:
43: #include <sys/param.h>
44: #include <sys/kernel.h>
45: #include <sys/buf.h>
46: #include <sys/device.h>
47: #include <sys/proc.h>
48: #include <sys/user.h>
49: #include <sys/malloc.h>
50: #include <sys/systm.h>
51: #include <sys/sched.h>
52:
53: #include <uvm/uvm_extern.h>
54:
55: #ifdef __vax__
56: #include <machine/pte.h>
57: #include <machine/pcb.h>
58: #endif
59: #include <machine/bus.h>
60:
61: #include <dev/bi/bireg.h>
62: #include <dev/bi/bivar.h>
63: #include <dev/bi/kdbreg.h>
64:
65: #include <dev/mscp/mscp.h>
66: #include <dev/mscp/mscpreg.h>
67: #include <dev/mscp/mscpvar.h>
68:
69: #define KDB_WL(adr, val) bus_space_write_4(sc->sc_iot, sc->sc_ioh, adr, val)
70: #define KDB_RL(adr) bus_space_read_4(sc->sc_iot, sc->sc_ioh, adr)
71: #define KDB_RS(adr) bus_space_read_2(sc->sc_iot, sc->sc_ioh, adr)
72:
73: #define b_forw b_hash.le_next
74: /*
75: * Software status, per controller.
76: */
77: struct kdb_softc {
78: struct device sc_dev; /* Autoconfig info */
79: caddr_t sc_kdb; /* Struct for kdb communication */
80: struct mscp_softc *sc_softc; /* MSCP info (per mscpvar.h) */
81: bus_dma_tag_t sc_dmat;
82: bus_dmamap_t sc_cmap; /* Control structures */
83: bus_space_tag_t sc_iot;
84: bus_space_handle_t sc_ioh;
85: };
86:
87: int kdbmatch(struct device *, struct cfdata *, void *);
88: void kdbattach(struct device *, struct device *, void *);
89: void kdbreset(int);
90: void kdbintr(void *);
91: void kdbctlrdone(struct device *);
92: int kdbprint(void *, const char *);
93: void kdbsaerror(struct device *, int);
94: void kdbgo(struct device *, struct mscp_xi *);
95:
96: struct cfattach kdb_ca = {
97: sizeof(struct kdb_softc), kdbmatch, kdbattach
98: };
99:
100: /*
101: * More driver definitions, for generic MSCP code.
102: */
103: struct mscp_ctlr kdb_mscp_ctlr = {
104: kdbctlrdone,
105: kdbgo,
106: kdbsaerror,
107: };
108:
109: int
110: kdbprint(aux, name)
111: void *aux;
112: const char *name;
113: {
114: if (name)
115: printf("%s: mscpbus", name);
116: return UNCONF;
117: }
118:
119: /*
120: * Poke at a supposed KDB to see if it is there.
121: */
122: int
123: kdbmatch(parent, cf, aux)
124: struct device *parent;
125: struct cfdata *cf;
126: void *aux;
127: {
128: struct bi_attach_args *ba = aux;
129:
130: if (bus_space_read_2(ba->ba_iot, ba->ba_ioh, BIREG_DTYPE) != BIDT_KDB50)
131: return 0;
132:
133: if (cf->cf_loc[BICF_NODE] != BICF_NODE_DEFAULT &&
134: cf->cf_loc[BICF_NODE] != ba->ba_nodenr)
135: return 0;
136:
137: return 1;
138: }
139:
140: void
141: kdbattach(parent, self, aux)
142: struct device *parent, *self;
143: void *aux;
144: {
145: struct kdb_softc *sc = (void *)self;
146: struct bi_attach_args *ba = aux;
147: struct mscp_attach_args ma;
148: volatile int i = 10000;
149: int error, rseg;
150: bus_dma_segment_t seg;
151:
152: printf("\n");
153: bi_intr_establish(ba->ba_icookie, ba->ba_ivec, kdbintr, sc);
154:
155: sc->sc_iot = ba->ba_iot;
156: sc->sc_ioh = ba->ba_ioh;
157: sc->sc_dmat = ba->ba_dmat;
158:
159: /*
160: * Map the communication area and command and
161: * response packets into Unibus space.
162: */
163: if ((error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct mscp_pack),
164: NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
165: printf("Alloc ctrl area %d\n", error);
166: return;
167: }
168: if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg,
169: sizeof(struct mscp_pack), &sc->sc_kdb,
170: BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) {
171: printf("Map ctrl area %d\n", error);
172: err: bus_dmamem_free(sc->sc_dmat, &seg, rseg);
173: return;
174: }
175: if ((error = bus_dmamap_create(sc->sc_dmat, sizeof(struct mscp_pack),
176: 1, sizeof(struct mscp_pack), 0, BUS_DMA_NOWAIT, &sc->sc_cmap))) {
177: printf("Create DMA map %d\n", error);
178: err2: bus_dmamem_unmap(sc->sc_dmat, sc->sc_kdb,
179: sizeof(struct mscp_pack));
180: goto err;
181: }
182: if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_cmap,
183: sc->sc_kdb, sizeof(struct mscp_pack), 0, BUS_DMA_NOWAIT))) {
184: printf("Load ctrl map %d\n", error);
185: bus_dmamap_destroy(sc->sc_dmat, sc->sc_cmap);
186: goto err2;
187: }
188: memset(sc->sc_kdb, 0, sizeof(struct mscp_pack));
189:
190: ma.ma_mc = &kdb_mscp_ctlr;
191: ma.ma_type = MSCPBUS_DISK|MSCPBUS_KDB;
192: ma.ma_uda = (struct mscp_pack *)sc->sc_kdb;
193: ma.ma_softc = &sc->sc_softc;
194: ma.ma_iot = sc->sc_iot;
195: ma.ma_iph = sc->sc_ioh + KDB_IP;
196: ma.ma_sah = sc->sc_ioh + KDB_SA;
197: ma.ma_swh = sc->sc_ioh + KDB_SW;
198: ma.ma_dmat = sc->sc_dmat;
199: ma.ma_dmam = sc->sc_cmap;
200: ma.ma_ivec = ba->ba_ivec;
201: ma.ma_ctlrnr = ba->ba_nodenr;
202: ma.ma_adapnr = ba->ba_busnr;
203:
204: KDB_WL(BIREG_VAXBICSR, KDB_RL(BIREG_VAXBICSR) | BICSR_NRST);
205: while (i--) /* Need delay??? */
206: ;
207: KDB_WL(BIREG_INTRDES, ba->ba_intcpu); /* Interrupt on CPU # */
208: KDB_WL(BIREG_BCICSR, KDB_RL(BIREG_BCICSR) |
209: BCI_STOPEN | BCI_IDENTEN | BCI_UINTEN | BCI_INTEN);
210: KDB_WL(BIREG_UINTRCSR, ba->ba_ivec);
211: config_found(&sc->sc_dev, &ma, kdbprint);
212: }
213:
214: void
215: kdbgo(usc, mxi)
216: struct device *usc;
217: struct mscp_xi *mxi;
218: {
219: struct kdb_softc *sc = (void *)usc;
220: struct buf *bp = mxi->mxi_bp;
221: struct mscp *mp = mxi->mxi_mp;
222: u_int32_t addr = (u_int32_t)bp->b_data;
223: u_int32_t mapaddr;
224: int err;
225:
226: /*
227: * The KDB50 wants to read VAX Page tables directly, therefore
228: * the result from bus_dmamap_load() is uninteresting. (But it
229: * should never fail!).
230: *
231: * On VAX, point to the corresponding page tables. (user/sys)
232: * On other systems, do something else...
233: */
234: err = bus_dmamap_load(sc->sc_dmat, mxi->mxi_dmam, bp->b_data,
235: bp->b_bcount, (bp->b_flags & B_PHYS ? bp->b_proc : 0),
236: 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: KERNEL_LOCK();
305: mscp_intr(sc->sc_softc);
306: KERNEL_UNLOCK();
307: }
308:
309: #ifdef notyet
310: /*
311: * The KDB50 has been reset. Reinitialise the controller
312: * and requeue outstanding I/O.
313: */
314: void
315: kdbreset(ctlr)
316: int ctlr;
317: {
318: struct kdb_softc *sc;
319:
320: sc = kdb_cd.cd_devs[ctlr];
321: printf(" kdb%d", ctlr);
322:
323:
324: /* reset queues and requeue pending transfers */
325: mscp_requeue(sc->sc_softc);
326:
327: /*
328: * If it fails to initialise we will notice later and
329: * try again (and again...). Do not call kdbstart()
330: * here; it will be done after the controller finishes
331: * initialisation.
332: */
333: if (kdbinit(sc))
334: printf(" (hung)");
335: }
336: #endif
337:
338: void
339: kdbctlrdone(usc)
340: struct device *usc;
341: {
342: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kdb.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / bi