Annotation of sys/dev/tc/tcds.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: tcds.c,v 1.4 2004/06/28 02:28:43 aaron Exp $ */
2: /* $NetBSD: tcds.c,v 1.3 2001/11/13 06:26:10 lukem Exp $ */
3:
4: /*-
5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
10: * NASA Ames Research Center.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: /*
42: * Copyright (c) 1994, 1995, 1996 Carnegie-Mellon University.
43: * All rights reserved.
44: *
45: * Author: Keith Bostic, Chris G. Demetriou
46: *
47: * Permission to use, copy, modify and distribute this software and
48: * its documentation is hereby granted, provided that both the copyright
49: * notice and this permission notice appear in all copies of the
50: * software, derivative works or modified versions, and any portions
51: * thereof, and that both notices appear in supporting documentation.
52: *
53: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
54: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
55: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
56: *
57: * Carnegie Mellon requests users of this software to return to
58: *
59: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
60: * School of Computer Science
61: * Carnegie Mellon University
62: * Pittsburgh PA 15213-3890
63: *
64: * any improvements or extensions that they make and grant Carnegie the
65: * rights to redistribute these changes.
66: */
67:
68: #include <sys/param.h>
69: #include <sys/kernel.h>
70: #include <sys/systm.h>
71: #include <sys/device.h>
72: #include <sys/malloc.h>
73:
74: #ifdef __alpha__
75: #include <machine/rpb.h>
76: #endif /* __alpha__ */
77:
78: #include <scsi/scsi_all.h>
79: #include <scsi/scsiconf.h>
80:
81: #include <dev/ic/ncr53c9xvar.h>
82:
83: #include <machine/bus.h>
84:
85: #include <dev/tc/tcvar.h>
86: #include <dev/tc/tcdsreg.h>
87: #include <dev/tc/tcdsvar.h>
88:
89: struct tcds_softc {
90: struct device sc_dv;
91: bus_space_tag_t sc_bst;
92: bus_space_handle_t sc_bsh;
93: bus_dma_tag_t sc_dmat;
94: void *sc_cookie;
95: int sc_flags;
96: struct tcds_slotconfig sc_slots[2];
97: };
98:
99: /* sc_flags */
100: #define TCDSF_BASEBOARD 0x01 /* baseboard on DEC 3000 */
101: #define TCDSF_FASTSCSI 0x02 /* supports Fast SCSI */
102:
103: /* Definition of the driver for autoconfig. */
104: int tcdsmatch(struct device *, void *, void *);
105: void tcdsattach(struct device *, struct device *, void *);
106: int tcdsprint(void *, const char *);
107: int tcdssubmatch(struct device *, void *, void *);
108:
109: struct cfattach tcds_ca = {
110: sizeof(struct tcds_softc), tcdsmatch, tcdsattach,
111: };
112:
113: struct cfdriver tcds_cd = {
114: NULL, "tcds", DV_DULL,
115: };
116:
117: /*static*/ int tcds_intr(void *);
118: /*static*/ int tcds_intrnull(void *);
119:
120: struct tcds_device {
121: const char *td_name;
122: int td_flags;
123: } tcds_devices[] = {
124: #ifdef __alpha__
125: { "PMAZ-DS ", TCDSF_BASEBOARD },
126: { "PMAZ-FS ", TCDSF_BASEBOARD|TCDSF_FASTSCSI },
127: #endif /* __alpha__ */
128: { "PMAZB-AA", 0 },
129: { "PMAZC-AA", TCDSF_FASTSCSI },
130: { NULL, 0 },
131: };
132:
133: struct tcds_device *tcds_lookup(const char *);
134: void tcds_params(struct tcds_softc *, int, int *, int *);
135:
136: struct tcds_device *
137: tcds_lookup(modname)
138: const char *modname;
139: {
140: struct tcds_device *td;
141:
142: for (td = tcds_devices; td->td_name != NULL; td++)
143: if (strncmp(td->td_name, modname, TC_ROM_LLEN) == 0)
144: return (td);
145:
146: return (NULL);
147: }
148:
149: int
150: tcdsmatch(parent, cfdata, aux)
151: struct device *parent;
152: void *cfdata, *aux;
153: {
154: struct tc_attach_args *ta = aux;
155:
156: return (tcds_lookup(ta->ta_modname) != NULL);
157: }
158:
159: void
160: tcdsattach(parent, self, aux)
161: struct device *parent, *self;
162: void *aux;
163: {
164: struct tcds_softc *sc = (struct tcds_softc *)self;
165: struct tc_attach_args *ta = aux;
166: struct tcdsdev_attach_args tcdsdev;
167: struct tcds_slotconfig *slotc;
168: struct tcds_device *td;
169: bus_space_handle_t sbsh[2];
170: int i, gpi2;
171:
172: td = tcds_lookup(ta->ta_modname);
173: if (td == NULL)
174: panic("tcdsattach: impossible");
175:
176: printf(": TurboChannel Dual SCSI");
177: if (td->td_flags & TCDSF_BASEBOARD)
178: printf(" (baseboard)");
179: printf("\n");
180:
181: sc->sc_flags = td->td_flags;
182:
183: sc->sc_bst = ta->ta_memt;
184: sc->sc_dmat = ta->ta_dmat;
185:
186: /*
187: * Map the device.
188: */
189: if (bus_space_map(sc->sc_bst, ta->ta_addr,
190: (TCDS_SCSI1_OFFSET + 0x100), 0, &sc->sc_bsh)) {
191: printf("%s: unable to map device\n", sc->sc_dv.dv_xname);
192: return;
193: }
194:
195: /*
196: * Now, slice off two subregions for the individual NCR SCSI chips.
197: */
198: if (bus_space_subregion(sc->sc_bst, sc->sc_bsh, TCDS_SCSI0_OFFSET,
199: 0x100, &sbsh[0]) ||
200: bus_space_subregion(sc->sc_bst, sc->sc_bsh, TCDS_SCSI1_OFFSET,
201: 0x100, &sbsh[1])) {
202: printf("%s: unable to subregion SCSI chip space\n",
203: sc->sc_dv.dv_xname);
204: return;
205: }
206:
207: sc->sc_cookie = ta->ta_cookie;
208:
209: tc_intr_establish(parent, sc->sc_cookie, TC_IPL_BIO, tcds_intr, sc);
210:
211: /*
212: * XXX
213: * IMER apparently has some random (or, not so random, but still
214: * not useful) bits set in it when the system boots. Clear it.
215: */
216: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_IMER, 0);
217:
218: /* XXX Initial contents of CIR? */
219:
220: /*
221: * Remember if GPI2 is set in the CIR; we'll need it later.
222: */
223: gpi2 = (bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR) &
224: TCDS_CIR_GPI_2) != 0;
225:
226: /*
227: * Set up the per-slot definitions for later use.
228: */
229:
230: /* fill in common information first */
231: for (i = 0; i < 2; i++) {
232: slotc = &sc->sc_slots[i];
233: bzero(slotc, sizeof *slotc); /* clear everything */
234:
235: evcount_attach(&slotc->sc_count, sc->sc_dv.dv_xname, NULL,
236: &evcount_intr);
237:
238: slotc->sc_slot = i;
239: slotc->sc_bst = sc->sc_bst;
240: slotc->sc_bsh = sc->sc_bsh;
241: slotc->sc_intrhand = tcds_intrnull;
242: slotc->sc_intrarg = (void *)(long)i;
243: }
244:
245: /* information for slot 0 */
246: slotc = &sc->sc_slots[0];
247: slotc->sc_resetbits = TCDS_CIR_SCSI0_RESET;
248: slotc->sc_intrmaskbits =
249: TCDS_IMER_SCSI0_MASK | TCDS_IMER_SCSI0_ENB;
250: slotc->sc_intrbits = TCDS_CIR_SCSI0_INT;
251: slotc->sc_dmabits = TCDS_CIR_SCSI0_DMAENA;
252: slotc->sc_errorbits = 0; /* XXX */
253: slotc->sc_sda = TCDS_SCSI0_DMA_ADDR;
254: slotc->sc_dic = TCDS_SCSI0_DMA_INTR;
255: slotc->sc_dud0 = TCDS_SCSI0_DMA_DUD0;
256: slotc->sc_dud1 = TCDS_SCSI0_DMA_DUD1;
257:
258: /* information for slot 1 */
259: slotc = &sc->sc_slots[1];
260: slotc->sc_resetbits = TCDS_CIR_SCSI1_RESET;
261: slotc->sc_intrmaskbits =
262: TCDS_IMER_SCSI1_MASK | TCDS_IMER_SCSI1_ENB;
263: slotc->sc_intrbits = TCDS_CIR_SCSI1_INT;
264: slotc->sc_dmabits = TCDS_CIR_SCSI1_DMAENA;
265: slotc->sc_errorbits = 0; /* XXX */
266: slotc->sc_sda = TCDS_SCSI1_DMA_ADDR;
267: slotc->sc_dic = TCDS_SCSI1_DMA_INTR;
268: slotc->sc_dud0 = TCDS_SCSI1_DMA_DUD0;
269: slotc->sc_dud1 = TCDS_SCSI1_DMA_DUD1;
270:
271: /* find the hardware attached to the TCDS ASIC */
272: for (i = 0; i < 2; i++) {
273: tcds_params(sc, i, &tcdsdev.tcdsda_id,
274: &tcdsdev.tcdsda_fast);
275:
276: tcdsdev.tcdsda_bst = sc->sc_bst;
277: tcdsdev.tcdsda_bsh = sbsh[i];
278: tcdsdev.tcdsda_dmat = sc->sc_dmat;
279: tcdsdev.tcdsda_chip = i;
280: tcdsdev.tcdsda_sc = &sc->sc_slots[i];
281: /*
282: * Determine the chip frequency. TCDSF_FASTSCSI will be set
283: * for TC option cards. For baseboard chips, GPI2 is set, for a
284: * 25MHz clock, else a 40MHz clock.
285: */
286: if ((sc->sc_flags & TCDSF_BASEBOARD && gpi2 == 0) ||
287: sc->sc_flags & TCDSF_FASTSCSI) {
288: tcdsdev.tcdsda_freq = 40000000;
289: tcdsdev.tcdsda_period = tcdsdev.tcdsda_fast ? 4 : 8;
290: } else {
291: tcdsdev.tcdsda_freq = 25000000;
292: tcdsdev.tcdsda_period = 5;
293: }
294: if (sc->sc_flags & TCDSF_BASEBOARD)
295: tcdsdev.tcdsda_variant = NCR_VARIANT_NCR53C94;
296: else
297: tcdsdev.tcdsda_variant = NCR_VARIANT_NCR53C96;
298:
299: tcds_scsi_reset(tcdsdev.tcdsda_sc);
300:
301: config_found_sm(self, &tcdsdev, tcdsprint, tcdssubmatch);
302: #ifdef __alpha__
303: /*
304: * The second SCSI chip isn't present on the baseboard TCDS
305: * on the DEC Alpha 3000/300 series.
306: */
307: if (sc->sc_flags & TCDSF_BASEBOARD &&
308: cputype == ST_DEC_3000_300)
309: break;
310: #endif /* __alpha__ */
311: }
312: }
313:
314: int
315: tcdssubmatch(parent, vcf, aux)
316: struct device *parent;
317: void *vcf, *aux;
318: {
319: struct tcdsdev_attach_args *tcdsdev = aux;
320: struct cfdata *cf = vcf;
321:
322: if (cf->cf_loc[0] != -1 &&
323: cf->cf_loc[0] != tcdsdev->tcdsda_chip)
324: return (0);
325:
326: return ((*cf->cf_attach->ca_match)(parent, vcf, aux));
327: }
328:
329: int
330: tcdsprint(aux, pnp)
331: void *aux;
332: const char *pnp;
333: {
334: struct tcdsdev_attach_args *tcdsdev = aux;
335:
336: /* Only ASCs can attach to TCDSs; easy. */
337: if (pnp)
338: printf("asc at %s", pnp);
339:
340: printf(" chip %d", tcdsdev->tcdsda_chip);
341:
342: return (UNCONF);
343: }
344:
345: void
346: tcds_intr_establish(tcds, slot, func, arg)
347: struct device *tcds;
348: int slot;
349: int (*func)(void *);
350: void *arg;
351: {
352: struct tcds_softc *sc = (struct tcds_softc *)tcds;
353:
354: if (sc->sc_slots[slot].sc_intrhand != tcds_intrnull)
355: panic("tcds_intr_establish: chip %d twice", slot);
356:
357: sc->sc_slots[slot].sc_intrhand = func;
358: sc->sc_slots[slot].sc_intrarg = arg;
359: tcds_scsi_reset(&sc->sc_slots[slot]);
360: }
361:
362: void
363: tcds_intr_disestablish(tcds, slot)
364: struct device *tcds;
365: int slot;
366: {
367: struct tcds_softc *sc = (struct tcds_softc *)tcds;
368:
369: if (sc->sc_slots[slot].sc_intrhand == tcds_intrnull)
370: panic("tcds_intr_disestablish: chip %d missing intr",
371: slot);
372:
373: sc->sc_slots[slot].sc_intrhand = tcds_intrnull;
374: sc->sc_slots[slot].sc_intrarg = (void *)(u_long)slot;
375:
376: tcds_dma_enable(&sc->sc_slots[slot], 0);
377: tcds_scsi_enable(&sc->sc_slots[slot], 0);
378: }
379:
380: int
381: tcds_intrnull(val)
382: void *val;
383: {
384:
385: panic("tcds_intrnull: uncaught TCDS intr for chip %lu",
386: (u_long)val);
387: }
388:
389: void
390: tcds_scsi_reset(sc)
391: struct tcds_slotconfig *sc;
392: {
393: u_int32_t cir;
394:
395: tcds_dma_enable(sc, 0);
396: tcds_scsi_enable(sc, 0);
397:
398: cir = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
399: TCDS_CIR_CLR(cir, sc->sc_resetbits);
400: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR, cir);
401:
402: DELAY(1);
403:
404: cir = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
405: TCDS_CIR_SET(cir, sc->sc_resetbits);
406: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR, cir);
407:
408: tcds_scsi_enable(sc, 1);
409: tcds_dma_enable(sc, 1);
410: }
411:
412: void
413: tcds_scsi_enable(sc, on)
414: struct tcds_slotconfig *sc;
415: int on;
416: {
417: u_int32_t imer;
418:
419: imer = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_IMER);
420:
421: if (on)
422: imer |= sc->sc_intrmaskbits;
423: else
424: imer &= ~sc->sc_intrmaskbits;
425:
426: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_IMER, imer);
427: }
428:
429: void
430: tcds_dma_enable(sc, on)
431: struct tcds_slotconfig *sc;
432: int on;
433: {
434: u_int32_t cir;
435:
436: cir = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
437:
438: /* XXX Clear/set IOSLOT/PBS bits. */
439: if (on)
440: TCDS_CIR_SET(cir, sc->sc_dmabits);
441: else
442: TCDS_CIR_CLR(cir, sc->sc_dmabits);
443:
444: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR, cir);
445: }
446:
447: int
448: tcds_scsi_isintr(sc, clear)
449: struct tcds_slotconfig *sc;
450: int clear;
451: {
452: u_int32_t cir;
453:
454: cir = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
455:
456: if ((cir & sc->sc_intrbits) != 0) {
457: if (clear) {
458: TCDS_CIR_CLR(cir, sc->sc_intrbits);
459: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR,
460: cir);
461: }
462: return (1);
463: } else
464: return (0);
465: }
466:
467: int
468: tcds_scsi_iserr(sc)
469: struct tcds_slotconfig *sc;
470: {
471: u_int32_t cir;
472:
473: cir = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
474: return ((cir & sc->sc_errorbits) != 0);
475: }
476:
477: int
478: tcds_intr(arg)
479: void *arg;
480: {
481: struct tcds_softc *sc = arg;
482: u_int32_t ir, ir0;
483:
484: /*
485: * XXX
486: * Copy and clear (gag!) the interrupts.
487: */
488: ir = ir0 = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR);
489: TCDS_CIR_CLR(ir0, TCDS_CIR_ALLINTR);
490: bus_space_write_4(sc->sc_bst, sc->sc_bsh, TCDS_CIR, ir0);
491: tc_syncbus();
492:
493: #define CHECKINTR(slot) \
494: if (ir & sc->sc_slots[slot].sc_intrbits) { \
495: sc->sc_slots[slot].sc_count.ec_count++; \
496: (void)(*sc->sc_slots[slot].sc_intrhand) \
497: (sc->sc_slots[slot].sc_intrarg); \
498: }
499: CHECKINTR(0);
500: CHECKINTR(1);
501: #undef CHECKINTR
502:
503: #ifdef DIAGNOSTIC
504: /*
505: * Interrupts not currently handled, but would like to know if they
506: * occur.
507: *
508: * XXX
509: * Don't know if we have to set the interrupt mask and enable bits
510: * in the IMER to allow some of them to happen?
511: */
512: #define PRINTINTR(msg, bits) \
513: if (ir & bits) \
514: printf("%s: %s", sc->sc_dv.dv_xname, msg);
515: PRINTINTR("SCSI0 DREQ interrupt.\n", TCDS_CIR_SCSI0_DREQ);
516: PRINTINTR("SCSI1 DREQ interrupt.\n", TCDS_CIR_SCSI1_DREQ);
517: PRINTINTR("SCSI0 prefetch interrupt.\n", TCDS_CIR_SCSI0_PREFETCH);
518: PRINTINTR("SCSI1 prefetch interrupt.\n", TCDS_CIR_SCSI1_PREFETCH);
519: PRINTINTR("SCSI0 DMA error.\n", TCDS_CIR_SCSI0_DMA);
520: PRINTINTR("SCSI1 DMA error.\n", TCDS_CIR_SCSI1_DMA);
521: PRINTINTR("SCSI0 DB parity error.\n", TCDS_CIR_SCSI0_DB);
522: PRINTINTR("SCSI1 DB parity error.\n", TCDS_CIR_SCSI1_DB);
523: PRINTINTR("SCSI0 DMA buffer parity error.\n", TCDS_CIR_SCSI0_DMAB_PAR);
524: PRINTINTR("SCSI1 DMA buffer parity error.\n", TCDS_CIR_SCSI1_DMAB_PAR);
525: PRINTINTR("SCSI0 DMA read parity error.\n", TCDS_CIR_SCSI0_DMAR_PAR);
526: PRINTINTR("SCSI1 DMA read parity error.\n", TCDS_CIR_SCSI1_DMAR_PAR);
527: PRINTINTR("TC write parity error.\n", TCDS_CIR_TCIOW_PAR);
528: PRINTINTR("TC I/O address parity error.\n", TCDS_CIR_TCIOA_PAR);
529: #undef PRINTINTR
530: #endif
531:
532: /*
533: * XXX
534: * The MACH source had this, with the comment:
535: * This is wrong, but machine keeps dying.
536: */
537: DELAY(1);
538:
539: return (1);
540: }
541:
542: void
543: tcds_params(sc, chip, idp, fastp)
544: struct tcds_softc *sc;
545: int chip, *idp, *fastp;
546: {
547: int id, fast;
548: u_int32_t ids;
549:
550: #ifdef __alpha__
551: if (sc->sc_flags & TCDSF_BASEBOARD) {
552: extern u_int8_t dec_3000_scsiid[], dec_3000_scsifast[];
553:
554: id = dec_3000_scsiid[chip];
555: fast = dec_3000_scsifast[chip];
556: } else
557: #endif /* __alpha__ */
558: {
559: /*
560: * SCSI IDs are stored in the EEPROM, along with whether or
561: * not the device is "fast". Chip 0 is the high nibble,
562: * chip 1 the low nibble.
563: */
564: ids = bus_space_read_4(sc->sc_bst, sc->sc_bsh, TCDS_EEPROM_IDS);
565: if (chip == 0)
566: ids >>= 4;
567:
568: id = ids & 0x7;
569: fast = ids & 0x8;
570: }
571:
572: if (id < 0 || id > 7) {
573: printf("%s: WARNING: bad SCSI ID %d for chip %d, using 7\n",
574: sc->sc_dv.dv_xname, id, chip);
575: id = 7;
576: }
577:
578: if (fast)
579: printf("%s: fast mode set for chip %d\n",
580: sc->sc_dv.dv_xname, chip);
581:
582: *idp = id;
583: *fastp = fast;
584: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tcds.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / tc