Annotation of sys/dev/ic/siop_common.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: siop_common.c,v 1.30 2007/08/05 19:05:09 kettenis Exp $ */
2: /* $NetBSD: siop_common.c,v 1.37 2005/02/27 00:27:02 perry Exp $ */
3:
4: /*
5: * Copyright (c) 2000, 2002 Manuel Bouyer.
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 by Manuel Bouyer.
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: /* SYM53c7/8xx PCI-SCSI I/O Processors driver */
35:
36: #include <sys/param.h>
37: #include <sys/systm.h>
38: #include <sys/device.h>
39: #include <sys/malloc.h>
40: #include <sys/buf.h>
41: #include <sys/kernel.h>
42: #include <sys/scsiio.h>
43:
44: #include <machine/endian.h>
45: #include <machine/bus.h>
46:
47: #include <scsi/scsi_all.h>
48: #include <scsi/scsi_message.h>
49: #include <scsi/scsiconf.h>
50:
51: #define SIOP_NEEDS_PERIOD_TABLES
52: #include <dev/ic/siopreg.h>
53: #include <dev/ic/siopvar_common.h>
54: #include <dev/ic/siopvar.h>
55:
56: #undef DEBUG
57: #undef DEBUG_DR
58: #undef DEBUG_NEG
59:
60: int
61: siop_common_attach(sc)
62: struct siop_common_softc *sc;
63: {
64: int error, i;
65: bus_dma_segment_t seg;
66: int rseg;
67:
68: /*
69: * Allocate DMA-safe memory for the script and map it.
70: */
71: if ((sc->features & SF_CHIP_RAM) == 0) {
72: error = bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE,
73: PAGE_SIZE, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
74: if (error) {
75: printf("%s: unable to allocate script DMA memory, "
76: "error = %d\n", sc->sc_dev.dv_xname, error);
77: return error;
78: }
79: error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, PAGE_SIZE,
80: (caddr_t *)&sc->sc_script,
81: BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
82: if (error) {
83: printf("%s: unable to map script DMA memory, "
84: "error = %d\n", sc->sc_dev.dv_xname, error);
85: return error;
86: }
87: error = bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1,
88: PAGE_SIZE, 0, BUS_DMA_NOWAIT, &sc->sc_scriptdma);
89: if (error) {
90: printf("%s: unable to create script DMA map, "
91: "error = %d\n", sc->sc_dev.dv_xname, error);
92: return error;
93: }
94: error = bus_dmamap_load(sc->sc_dmat, sc->sc_scriptdma,
95: sc->sc_script, PAGE_SIZE, NULL, BUS_DMA_NOWAIT);
96: if (error) {
97: printf("%s: unable to load script DMA map, "
98: "error = %d\n", sc->sc_dev.dv_xname, error);
99: return error;
100: }
101: sc->sc_scriptaddr =
102: sc->sc_scriptdma->dm_segs[0].ds_addr;
103: sc->ram_size = PAGE_SIZE;
104: }
105:
106: /*
107: * sc->sc_link is the template for all device sc_link's
108: * for devices attached to this adapter. It is passed to
109: * the upper layers in config_found().
110: */
111: sc->sc_link.adapter_softc = sc;
112: sc->sc_link.adapter_buswidth =
113: (sc->features & SF_BUS_WIDE) ? 16 : 8;
114: sc->sc_link.adapter_target =
115: bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCID);
116: if (sc->sc_link.adapter_target == 0 ||
117: sc->sc_link.adapter_target >=
118: sc->sc_link.adapter_buswidth)
119: sc->sc_link.adapter_target = SIOP_DEFAULT_TARGET;
120:
121: for (i = 0; i < 16; i++)
122: sc->targets[i] = NULL;
123:
124: /* find min/max sync period for this chip */
125: sc->st_maxsync = 0;
126: sc->dt_maxsync = 0;
127: sc->st_minsync = 255;
128: sc->dt_minsync = 255;
129: for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]); i++) {
130: if (sc->clock_period != scf_period[i].clock)
131: continue;
132: if (sc->st_maxsync < scf_period[i].period)
133: sc->st_maxsync = scf_period[i].period;
134: if (sc->st_minsync > scf_period[i].period)
135: sc->st_minsync = scf_period[i].period;
136: }
137: if (sc->st_maxsync == 255 || sc->st_minsync == 0)
138: panic("siop: can't find my sync parameters");
139: for (i = 0; i < sizeof(dt_scf_period) / sizeof(dt_scf_period[0]); i++) {
140: if (sc->clock_period != dt_scf_period[i].clock)
141: continue;
142: if (sc->dt_maxsync < dt_scf_period[i].period)
143: sc->dt_maxsync = dt_scf_period[i].period;
144: if (sc->dt_minsync > dt_scf_period[i].period)
145: sc->dt_minsync = dt_scf_period[i].period;
146: }
147: if (sc->dt_maxsync == 255 || sc->dt_minsync == 0)
148: panic("siop: can't find my sync parameters");
149: return 0;
150: }
151:
152: void
153: siop_common_reset(sc)
154: struct siop_common_softc *sc;
155: {
156: u_int32_t stest3;
157:
158: /* reset the chip */
159: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, ISTAT_SRST);
160: delay(1000);
161: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_ISTAT, 0);
162:
163: /* init registers */
164: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL0,
165: SCNTL0_ARB_MASK | SCNTL0_EPC | SCNTL0_AAP);
166: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, 0);
167: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3, sc->clock_div);
168: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER, 0);
169: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DIEN, 0xff);
170: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN0,
171: 0xff & ~(SIEN0_CMP | SIEN0_SEL | SIEN0_RSL));
172: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SIEN1,
173: 0xff & ~(SIEN1_HTH | SIEN1_GEN));
174: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2, 0);
175: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, STEST3_TE);
176: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STIME0,
177: (0xb << STIME0_SEL_SHIFT));
178: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCID,
179: sc->sc_link.adapter_target | SCID_RRE);
180: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_RESPID0,
181: 1 << sc->sc_link.adapter_target);
182: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_DCNTL,
183: (sc->features & SF_CHIP_PF) ? DCNTL_COM | DCNTL_PFEN : DCNTL_COM);
184: if (sc->features & SF_CHIP_AAIP)
185: bus_space_write_1(sc->sc_rt, sc->sc_rh,
186: SIOP_AIPCNTL1, AIPCNTL1_DIS);
187:
188: /* enable clock doubler or quadrupler if appropriate */
189: if (sc->features & (SF_CHIP_DBLR | SF_CHIP_QUAD)) {
190: stest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3);
191: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
192: STEST1_DBLEN);
193: if (sc->features & SF_CHIP_QUAD) {
194: /* wait for PPL to lock */
195: while ((bus_space_read_1(sc->sc_rt, sc->sc_rh,
196: SIOP_STEST4) & STEST4_LOCK) == 0)
197: delay(10);
198: } else {
199: /* data sheet says 20us - more won't hurt */
200: delay(100);
201: }
202: /* halt scsi clock, select doubler/quad, restart clock */
203: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3,
204: stest3 | STEST3_HSC);
205: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1,
206: STEST1_DBLEN | STEST1_DBLSEL);
207: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST3, stest3);
208: } else {
209: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST1, 0);
210: }
211: if (sc->features & SF_CHIP_FIFO)
212: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5,
213: bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST5) |
214: CTEST5_DFS);
215: if (sc->features & SF_CHIP_LED0) {
216: /* Set GPIO0 as output if software LED control is required */
217: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_GPCNTL,
218: bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_GPCNTL) & 0xfe);
219: }
220: if (sc->features & SF_BUS_ULTRA3) {
221: /* reset SCNTL4 */
222: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL4, 0);
223: }
224: sc->mode = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST4) &
225: STEST4_MODE_MASK;
226:
227: /*
228: * initialise the RAM. Without this we may get scsi gross errors on
229: * the 1010
230: */
231: if (sc->features & SF_CHIP_RAM)
232: bus_space_set_region_4(sc->sc_ramt, sc->sc_ramh,
233: 0, 0, sc->ram_size / 4);
234: sc->sc_reset(sc);
235: }
236:
237: /* prepare tables before sending a cmd */
238: void
239: siop_setuptables(siop_cmd)
240: struct siop_common_cmd *siop_cmd;
241: {
242: int i;
243: struct siop_common_softc *sc = siop_cmd->siop_sc;
244: struct scsi_xfer *xs = siop_cmd->xs;
245: int target = xs->sc_link->target;
246: int lun = xs->sc_link->lun;
247: int msgoffset = 1;
248: int *targ_flags = &sc->targets[target]->flags;
249: int quirks;
250:
251: siop_cmd->siop_tables->id = siop_htoc32(sc, sc->targets[target]->id);
252: memset(siop_cmd->siop_tables->msg_out, 0,
253: sizeof(siop_cmd->siop_tables->msg_out));
254: /* request sense doesn't disconnect */
255: if (siop_cmd->status == CMDST_SENSE)
256: siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 0);
257: else if ((sc->features & SF_CHIP_GEBUG) &&
258: (sc->targets[target]->flags & TARF_ISWIDE) == 0)
259: /*
260: * 1010 bug: it seems that the 1010 has problems with reselect
261: * when not in wide mode (generate false SCSI gross error).
262: * The FreeBSD sym driver has comments about it but their
263: * workaround (disable SCSI gross error reporting) doesn't
264: * work with my adapter. So disable disconnect when not
265: * wide.
266: */
267: siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 0);
268: else
269: siop_cmd->siop_tables->msg_out[0] = MSG_IDENTIFY(lun, 1);
270: siop_cmd->siop_tables->t_msgout.count = siop_htoc32(sc, msgoffset);
271: if (sc->targets[target]->status == TARST_ASYNC) {
272: *targ_flags &= TARF_DT; /* Save TARF_DT 'cuz we don't set it here */
273: quirks = xs->sc_link->quirks;
274:
275: if ((quirks & SDEV_NOTAGS) == 0)
276: *targ_flags |= TARF_TAG;
277: if (((quirks & SDEV_NOWIDE) == 0) &&
278: (sc->features & SF_BUS_WIDE))
279: *targ_flags |= TARF_WIDE;
280: if ((quirks & SDEV_NOSYNC) == 0)
281: *targ_flags |= TARF_SYNC;
282:
283: if ((sc->features & SF_CHIP_GEBUG) &&
284: (*targ_flags & TARF_WIDE) == 0)
285: /*
286: * 1010 workaround: can't do disconnect if not wide,
287: * so can't do tag
288: */
289: *targ_flags &= ~TARF_TAG;
290:
291: /* Safe to call siop_add_dev() multiple times */
292: siop_add_dev((struct siop_softc *)sc, target, lun);
293:
294: if ((*targ_flags & TARF_DT) &&
295: (sc->mode == STEST4_MODE_LVD)) {
296: sc->targets[target]->status = TARST_PPR_NEG;
297: siop_ppr_msg(siop_cmd, msgoffset, sc->dt_minsync,
298: sc->maxoff);
299: } else if (*targ_flags & TARF_WIDE) {
300: sc->targets[target]->status = TARST_WIDE_NEG;
301: siop_wdtr_msg(siop_cmd, msgoffset,
302: MSG_EXT_WDTR_BUS_16_BIT);
303: } else if (*targ_flags & TARF_SYNC) {
304: sc->targets[target]->status = TARST_SYNC_NEG;
305: siop_sdtr_msg(siop_cmd, msgoffset, sc->st_minsync,
306: (sc->maxoff > 31) ? 31 : sc->maxoff);
307: } else {
308: sc->targets[target]->status = TARST_OK;
309: siop_update_xfer_mode(sc, target);
310: }
311: } else if (sc->targets[target]->status == TARST_OK &&
312: (*targ_flags & TARF_TAG) &&
313: siop_cmd->status != CMDST_SENSE) {
314: siop_cmd->flags |= CMDFL_TAG;
315: }
316: siop_cmd->siop_tables->status =
317: siop_htoc32(sc, SCSI_SIOP_NOSTATUS); /* set invalid status */
318:
319: if ((xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) ||
320: siop_cmd->status == CMDST_SENSE) {
321: bzero(siop_cmd->siop_tables->data,
322: sizeof(siop_cmd->siop_tables->data));
323: for (i = 0; i < siop_cmd->dmamap_data->dm_nsegs; i++) {
324: siop_cmd->siop_tables->data[i].count =
325: siop_htoc32(sc,
326: siop_cmd->dmamap_data->dm_segs[i].ds_len);
327: siop_cmd->siop_tables->data[i].addr =
328: siop_htoc32(sc,
329: siop_cmd->dmamap_data->dm_segs[i].ds_addr);
330: }
331: }
332: }
333:
334: int
335: siop_wdtr_neg(siop_cmd)
336: struct siop_common_cmd *siop_cmd;
337: {
338: struct siop_common_softc *sc = siop_cmd->siop_sc;
339: struct siop_common_target *siop_target = siop_cmd->siop_target;
340: int target = siop_cmd->xs->sc_link->target;
341: struct siop_common_xfer *tables = siop_cmd->siop_tables;
342:
343: if (siop_target->status == TARST_WIDE_NEG) {
344: /* we initiated wide negotiation */
345: switch (tables->msg_in[3]) {
346: case MSG_EXT_WDTR_BUS_8_BIT:
347: siop_target->flags &= ~TARF_ISWIDE;
348: sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
349: break;
350: case MSG_EXT_WDTR_BUS_16_BIT:
351: if (siop_target->flags & TARF_WIDE) {
352: siop_target->flags |= TARF_ISWIDE;
353: sc->targets[target]->id |= (SCNTL3_EWS << 24);
354: break;
355: }
356: /* FALLTHROUGH */
357: default:
358: /*
359: * hum, we got more than what we can handle, shouldn't
360: * happen. Reject, and stay async
361: */
362: siop_target->flags &= ~TARF_ISWIDE;
363: siop_target->status = TARST_OK;
364: siop_target->offset = siop_target->period = 0;
365: siop_update_xfer_mode(sc, target);
366: printf("%s: rejecting invalid wide negotiation from "
367: "target %d (%d)\n", sc->sc_dev.dv_xname, target,
368: tables->msg_in[3]);
369: tables->t_msgout.count = siop_htoc32(sc, 1);
370: tables->msg_out[0] = MSG_MESSAGE_REJECT;
371: return SIOP_NEG_MSGOUT;
372: }
373: tables->id = siop_htoc32(sc, sc->targets[target]->id);
374: bus_space_write_1(sc->sc_rt, sc->sc_rh,
375: SIOP_SCNTL3,
376: (sc->targets[target]->id >> 24) & 0xff);
377: /* we now need to do sync */
378: if (siop_target->flags & TARF_SYNC) {
379: siop_target->status = TARST_SYNC_NEG;
380: siop_sdtr_msg(siop_cmd, 0, sc->st_minsync,
381: (sc->maxoff > 31) ? 31 : sc->maxoff);
382: return SIOP_NEG_MSGOUT;
383: } else {
384: siop_target->status = TARST_OK;
385: siop_update_xfer_mode(sc, target);
386: return SIOP_NEG_ACK;
387: }
388: } else {
389: /* target initiated wide negotiation */
390: if (tables->msg_in[3] >= MSG_EXT_WDTR_BUS_16_BIT
391: && (siop_target->flags & TARF_WIDE)) {
392: siop_target->flags |= TARF_ISWIDE;
393: sc->targets[target]->id |= SCNTL3_EWS << 24;
394: } else {
395: siop_target->flags &= ~TARF_ISWIDE;
396: sc->targets[target]->id &= ~(SCNTL3_EWS << 24);
397: }
398: tables->id = siop_htoc32(sc, sc->targets[target]->id);
399: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
400: (sc->targets[target]->id >> 24) & 0xff);
401: /*
402: * we did reset wide parameters, so fall back to async,
403: * but don't schedule a sync neg, target should initiate it
404: */
405: siop_target->status = TARST_OK;
406: siop_target->offset = siop_target->period = 0;
407: siop_update_xfer_mode(sc, target);
408: siop_wdtr_msg(siop_cmd, 0, (siop_target->flags & TARF_ISWIDE) ?
409: MSG_EXT_WDTR_BUS_16_BIT : MSG_EXT_WDTR_BUS_8_BIT);
410: return SIOP_NEG_MSGOUT;
411: }
412: }
413:
414: int
415: siop_ppr_neg(siop_cmd)
416: struct siop_common_cmd *siop_cmd;
417: {
418: struct siop_common_softc *sc = siop_cmd->siop_sc;
419: struct siop_common_target *siop_target = siop_cmd->siop_target;
420: int target = siop_cmd->xs->sc_link->target;
421: struct siop_common_xfer *tables = siop_cmd->siop_tables;
422: int sync, offset, options, scf = 0;
423: int i;
424:
425: #ifdef DEBUG_NEG
426: printf("%s: answer on ppr negotiation:", sc->sc_dev.dv_xname);
427: for (i = 0; i < 8; i++)
428: printf(" 0x%x", tables->msg_in[i]);
429: printf("\n");
430: #endif
431:
432: if (siop_target->status == TARST_PPR_NEG) {
433: /* we initiated PPR negotiation */
434: sync = tables->msg_in[3];
435: offset = tables->msg_in[5];
436: options = tables->msg_in[7];
437: if (options != MSG_EXT_PPR_PROT_DT) {
438: /* should't happen */
439: printf("%s: ppr negotiation for target %d: "
440: "no DT option\n", sc->sc_dev.dv_xname, target);
441: siop_target->status = TARST_ASYNC;
442: siop_target->flags &= ~(TARF_DT | TARF_ISDT);
443: siop_target->offset = 0;
444: siop_target->period = 0;
445: goto reject;
446: }
447:
448: if (offset > sc->maxoff || sync < sc->dt_minsync ||
449: sync > sc->dt_maxsync) {
450: printf("%s: ppr negotiation for target %d: "
451: "offset (%d) or sync (%d) out of range\n",
452: sc->sc_dev.dv_xname, target, offset, sync);
453: /* should not happen */
454: siop_target->status = TARST_ASYNC;
455: siop_target->flags &= ~(TARF_DT | TARF_ISDT);
456: siop_target->offset = 0;
457: siop_target->period = 0;
458: goto reject;
459: } else {
460: for (i = 0; i <
461: sizeof(dt_scf_period) / sizeof(dt_scf_period[0]);
462: i++) {
463: if (sc->clock_period != dt_scf_period[i].clock)
464: continue;
465: if (dt_scf_period[i].period == sync) {
466: /* ok, found it. we now are sync. */
467: siop_target->offset = offset;
468: siop_target->period = sync;
469: scf = dt_scf_period[i].scf;
470: siop_target->flags |= TARF_ISDT;
471: }
472: }
473: if ((siop_target->flags & TARF_ISDT) == 0) {
474: printf("%s: ppr negotiation for target %d: "
475: "sync (%d) incompatible with adapter\n",
476: sc->sc_dev.dv_xname, target, sync);
477: /*
478: * we didn't find it in our table, do async
479: * send reject msg, start SDTR/WDTR neg
480: */
481: siop_target->status = TARST_ASYNC;
482: siop_target->flags &= ~(TARF_DT | TARF_ISDT);
483: siop_target->offset = 0;
484: siop_target->period = 0;
485: goto reject;
486: }
487: }
488: if (tables->msg_in[6] != 1) {
489: printf("%s: ppr negotiation for target %d: "
490: "transfer width (%d) incompatible with dt\n",
491: sc->sc_dev.dv_xname, target, tables->msg_in[6]);
492: /* DT mode can only be done with wide transfers */
493: siop_target->status = TARST_ASYNC;
494: siop_target->flags &= ~(TARF_DT | TARF_ISDT);
495: siop_target->offset = 0;
496: siop_target->period = 0;
497: goto reject;
498: }
499: siop_target->flags |= TARF_ISWIDE;
500: sc->targets[target]->id |= (SCNTL3_EWS << 24);
501: sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
502: sc->targets[target]->id |= scf << (24 + SCNTL3_SCF_SHIFT);
503: sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
504: sc->targets[target]->id |=
505: (siop_target->offset & SXFER_MO_MASK) << 8;
506: sc->targets[target]->id &= ~0xff;
507: sc->targets[target]->id |= SCNTL4_U3EN;
508: siop_target->status = TARST_OK;
509: siop_update_xfer_mode(sc, target);
510: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
511: (sc->targets[target]->id >> 24) & 0xff);
512: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER,
513: (sc->targets[target]->id >> 8) & 0xff);
514: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL4,
515: sc->targets[target]->id & 0xff);
516: return SIOP_NEG_ACK;
517: } else {
518: /* target initiated PPR negotiation, shouldn't happen */
519: printf("%s: rejecting invalid PPR negotiation from "
520: "target %d\n", sc->sc_dev.dv_xname, target);
521: reject:
522: tables->t_msgout.count = siop_htoc32(sc, 1);
523: tables->msg_out[0] = MSG_MESSAGE_REJECT;
524: return SIOP_NEG_MSGOUT;
525: }
526: }
527:
528: int
529: siop_sdtr_neg(siop_cmd)
530: struct siop_common_cmd *siop_cmd;
531: {
532: struct siop_common_softc *sc = siop_cmd->siop_sc;
533: struct siop_common_target *siop_target = siop_cmd->siop_target;
534: int target = siop_cmd->xs->sc_link->target;
535: int sync, maxoffset, offset, i;
536: int send_msgout = 0;
537: struct siop_common_xfer *tables = siop_cmd->siop_tables;
538:
539: /* limit to Ultra/2 parameters, need PPR for Ultra/3 */
540: maxoffset = (sc->maxoff > 31) ? 31 : sc->maxoff;
541:
542: sync = tables->msg_in[3];
543: offset = tables->msg_in[4];
544:
545: if (siop_target->status == TARST_SYNC_NEG) {
546: /* we initiated sync negotiation */
547: siop_target->status = TARST_OK;
548: #ifdef DEBUG
549: printf("sdtr: sync %d offset %d\n", sync, offset);
550: #endif
551: if (offset > maxoffset || sync < sc->st_minsync ||
552: sync > sc->st_maxsync)
553: goto reject;
554: for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]);
555: i++) {
556: if (sc->clock_period != scf_period[i].clock)
557: continue;
558: if (scf_period[i].period == sync) {
559: /* ok, found it. we now are sync. */
560: siop_target->offset = offset;
561: siop_target->period = sync;
562: sc->targets[target]->id &=
563: ~(SCNTL3_SCF_MASK << 24);
564: sc->targets[target]->id |= scf_period[i].scf
565: << (24 + SCNTL3_SCF_SHIFT);
566: if (sync < 25 && /* Ultra */
567: (sc->features & SF_BUS_ULTRA3) == 0)
568: sc->targets[target]->id |=
569: SCNTL3_ULTRA << 24;
570: else
571: sc->targets[target]->id &=
572: ~(SCNTL3_ULTRA << 24);
573: sc->targets[target]->id &=
574: ~(SXFER_MO_MASK << 8);
575: sc->targets[target]->id |=
576: (offset & SXFER_MO_MASK) << 8;
577: sc->targets[target]->id &= ~0xff; /* scntl4 */
578: goto end;
579: }
580: }
581: /*
582: * we didn't find it in our table, do async and send reject
583: * msg
584: */
585: reject:
586: send_msgout = 1;
587: tables->t_msgout.count = siop_htoc32(sc, 1);
588: tables->msg_out[0] = MSG_MESSAGE_REJECT;
589: sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
590: sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
591: sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
592: sc->targets[target]->id &= ~0xff; /* scntl4 */
593: siop_target->offset = siop_target->period = 0;
594: } else { /* target initiated sync neg */
595: #ifdef DEBUG
596: printf("sdtr (target): sync %d offset %d\n", sync, offset);
597: #endif
598: if (offset == 0 || sync > sc->st_maxsync) { /* async */
599: goto async;
600: }
601: if (offset > maxoffset)
602: offset = maxoffset;
603: if (sync < sc->st_minsync)
604: sync = sc->st_minsync;
605: /* look for sync period */
606: for (i = 0; i < sizeof(scf_period) / sizeof(scf_period[0]);
607: i++) {
608: if (sc->clock_period != scf_period[i].clock)
609: continue;
610: if (scf_period[i].period == sync) {
611: /* ok, found it. we now are sync. */
612: siop_target->offset = offset;
613: siop_target->period = sync;
614: sc->targets[target]->id &=
615: ~(SCNTL3_SCF_MASK << 24);
616: sc->targets[target]->id |= scf_period[i].scf
617: << (24 + SCNTL3_SCF_SHIFT);
618: if (sync < 25 && /* Ultra */
619: (sc->features & SF_BUS_ULTRA3) == 0)
620: sc->targets[target]->id |=
621: SCNTL3_ULTRA << 24;
622: else
623: sc->targets[target]->id &=
624: ~(SCNTL3_ULTRA << 24);
625: sc->targets[target]->id &=
626: ~(SXFER_MO_MASK << 8);
627: sc->targets[target]->id |=
628: (offset & SXFER_MO_MASK) << 8;
629: sc->targets[target]->id &= ~0xff; /* scntl4 */
630: siop_sdtr_msg(siop_cmd, 0, sync, offset);
631: send_msgout = 1;
632: goto end;
633: }
634: }
635: async:
636: siop_target->offset = siop_target->period = 0;
637: sc->targets[target]->id &= ~(SCNTL3_SCF_MASK << 24);
638: sc->targets[target]->id &= ~(SCNTL3_ULTRA << 24);
639: sc->targets[target]->id &= ~(SXFER_MO_MASK << 8);
640: sc->targets[target]->id &= ~0xff; /* scntl4 */
641: siop_sdtr_msg(siop_cmd, 0, 0, 0);
642: send_msgout = 1;
643: }
644: end:
645: if (siop_target->status == TARST_OK)
646: siop_update_xfer_mode(sc, target);
647: #ifdef DEBUG
648: printf("id now 0x%x\n", sc->targets[target]->id);
649: #endif
650: tables->id = siop_htoc32(sc, sc->targets[target]->id);
651: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL3,
652: (sc->targets[target]->id >> 24) & 0xff);
653: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SXFER,
654: (sc->targets[target]->id >> 8) & 0xff);
655: if (send_msgout) {
656: return SIOP_NEG_MSGOUT;
657: } else {
658: return SIOP_NEG_ACK;
659: }
660: }
661:
662: void
663: siop_sdtr_msg(siop_cmd, offset, ssync, soff)
664: struct siop_common_cmd *siop_cmd;
665: int offset;
666: int ssync, soff;
667: {
668: siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
669: siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_SDTR_LEN;
670: siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_SDTR;
671: siop_cmd->siop_tables->msg_out[offset + 3] = ssync;
672: siop_cmd->siop_tables->msg_out[offset + 4] = soff;
673: siop_cmd->siop_tables->t_msgout.count =
674: siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_SDTR_LEN + 2);
675: }
676:
677: void
678: siop_wdtr_msg(siop_cmd, offset, wide)
679: struct siop_common_cmd *siop_cmd;
680: int offset;
681: int wide;
682: {
683: siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
684: siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_WDTR_LEN;
685: siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_WDTR;
686: siop_cmd->siop_tables->msg_out[offset + 3] = wide;
687: siop_cmd->siop_tables->t_msgout.count =
688: siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_WDTR_LEN + 2);
689: }
690:
691: void
692: siop_ppr_msg(siop_cmd, offset, ssync, soff)
693: struct siop_common_cmd *siop_cmd;
694: int offset;
695: int ssync, soff;
696: {
697: siop_cmd->siop_tables->msg_out[offset + 0] = MSG_EXTENDED;
698: siop_cmd->siop_tables->msg_out[offset + 1] = MSG_EXT_PPR_LEN;
699: siop_cmd->siop_tables->msg_out[offset + 2] = MSG_EXT_PPR;
700: siop_cmd->siop_tables->msg_out[offset + 3] = ssync;
701: siop_cmd->siop_tables->msg_out[offset + 4] = 0; /* reserved */
702: siop_cmd->siop_tables->msg_out[offset + 5] = soff;
703: siop_cmd->siop_tables->msg_out[offset + 6] = 1; /* wide */
704: siop_cmd->siop_tables->msg_out[offset + 7] = MSG_EXT_PPR_PROT_DT;
705: siop_cmd->siop_tables->t_msgout.count =
706: siop_htoc32(siop_cmd->siop_sc, offset + MSG_EXT_PPR_LEN + 2);
707: }
708:
709: void
710: siop_minphys(bp)
711: struct buf *bp;
712: {
713: if (bp->b_bcount > SIOP_MAXFER)
714: bp->b_bcount = SIOP_MAXFER;
715:
716: minphys(bp);
717: }
718:
719: void
720: siop_ma(siop_cmd)
721: struct siop_common_cmd *siop_cmd;
722: {
723: int offset, dbc, sstat;
724: struct siop_common_softc *sc = siop_cmd->siop_sc;
725: scr_table_t *table; /* table with partial xfer */
726:
727: /*
728: * compute how much of the current table didn't get handled when
729: * a phase mismatch occurs
730: */
731: if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
732: == 0)
733: return; /* no valid data transfer */
734:
735: offset = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCRATCHA + 1);
736: if (offset >= SIOP_NSG) {
737: printf("%s: bad offset in siop_sdp (%d)\n",
738: sc->sc_dev.dv_xname, offset);
739: return;
740: }
741: table = &siop_cmd->siop_tables->data[offset];
742: #ifdef DEBUG_DR
743: printf("siop_ma: offset %d count=%d addr=0x%x ", offset,
744: table->count, table->addr);
745: #endif
746: dbc = bus_space_read_4(sc->sc_rt, sc->sc_rh, SIOP_DBC) & 0x00ffffff;
747: if (siop_cmd->xs->flags & SCSI_DATA_OUT) {
748: if (sc->features & SF_CHIP_DFBC) {
749: dbc +=
750: bus_space_read_2(sc->sc_rt, sc->sc_rh, SIOP_DFBC);
751: } else {
752: /* need to account stale data in FIFO */
753: int dfifo =
754: bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_DFIFO);
755: if (sc->features & SF_CHIP_FIFO) {
756: dfifo |= (bus_space_read_1(sc->sc_rt, sc->sc_rh,
757: SIOP_CTEST5) & CTEST5_BOMASK) << 8;
758: dbc += (dfifo - (dbc & 0x3ff)) & 0x3ff;
759: } else {
760: dbc += (dfifo - (dbc & 0x7f)) & 0x7f;
761: }
762: }
763: sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SSTAT0);
764: if (sstat & SSTAT0_OLF)
765: dbc++;
766: if ((sstat & SSTAT0_ORF) && (sc->features & SF_CHIP_DFBC) == 0)
767: dbc++;
768: if (siop_cmd->siop_target->flags & TARF_ISWIDE) {
769: sstat = bus_space_read_1(sc->sc_rt, sc->sc_rh,
770: SIOP_SSTAT2);
771: if (sstat & SSTAT2_OLF1)
772: dbc++;
773: if ((sstat & SSTAT2_ORF1) &&
774: (sc->features & SF_CHIP_DFBC) == 0)
775: dbc++;
776: }
777: /* clear the FIFO */
778: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
779: bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) |
780: CTEST3_CLF);
781: }
782: siop_cmd->flags |= CMDFL_RESID;
783: siop_cmd->resid = dbc;
784: }
785:
786: void
787: siop_sdp(siop_cmd, offset)
788: struct siop_common_cmd *siop_cmd;
789: int offset;
790: {
791: struct siop_common_softc *sc = siop_cmd->siop_sc;
792: scr_table_t *table;
793:
794: if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
795: == 0)
796: return; /* no data pointers to save */
797:
798: /*
799: * offset == SIOP_NSG may be a valid condition if we get a Save data
800: * pointer when the xfer is done. Just ignore the Save data pointer
801: * in this case
802: */
803: if (offset == SIOP_NSG)
804: return;
805: #ifdef DIAGNOSTIC
806: if (offset > SIOP_NSG) {
807: sc_print_addr(siop_cmd->xs->sc_link);
808: printf(": offset %d > %d\n", offset, SIOP_NSG);
809: panic("siop_sdp: offset");
810: }
811: #endif
812: /*
813: * Save data pointer. We do this by adjusting the tables to point
814: * at the begginning of the data not yet transfered.
815: * offset points to the first table with untransfered data.
816: */
817:
818: /*
819: * before doing that we decrease resid from the amount of data which
820: * has been transfered.
821: */
822: siop_update_resid(siop_cmd, offset);
823:
824: /*
825: * First let see if we have a resid from a phase mismatch. If so,
826: * we have to adjst the table at offset to remove transfered data.
827: */
828: if (siop_cmd->flags & CMDFL_RESID) {
829: siop_cmd->flags &= ~CMDFL_RESID;
830: table = &siop_cmd->siop_tables->data[offset];
831: /* "cut" already transfered data from this table */
832: table->addr =
833: siop_htoc32(sc, siop_ctoh32(sc, table->addr) +
834: siop_ctoh32(sc, table->count) - siop_cmd->resid);
835: table->count = siop_htoc32(sc, siop_cmd->resid);
836: }
837:
838: /*
839: * now we can remove entries which have been transfered.
840: * We just move the entries with data left at the beggining of the
841: * tables
842: */
843: bcopy(&siop_cmd->siop_tables->data[offset],
844: &siop_cmd->siop_tables->data[0],
845: (SIOP_NSG - offset) * sizeof(scr_table_t));
846: }
847:
848: void
849: siop_update_resid(siop_cmd, offset)
850: struct siop_common_cmd *siop_cmd;
851: int offset;
852: {
853: struct siop_common_softc *sc = siop_cmd->siop_sc;
854: scr_table_t *table;
855: int i;
856:
857: if ((siop_cmd->xs->flags & (SCSI_DATA_OUT | SCSI_DATA_IN))
858: == 0)
859: return; /* no data to transfer */
860:
861: /*
862: * update resid. First account for the table entries which have
863: * been fully completed.
864: */
865: for (i = 0; i < offset; i++)
866: siop_cmd->xs->resid -=
867: siop_ctoh32(sc, siop_cmd->siop_tables->data[i].count);
868: /*
869: * if CMDFL_RESID is set, the last table (pointed by offset) is a
870: * partial transfers. If not, offset points to the entry folloing
871: * the last full transfer.
872: */
873: if (siop_cmd->flags & CMDFL_RESID) {
874: table = &siop_cmd->siop_tables->data[offset];
875: siop_cmd->xs->resid -=
876: siop_ctoh32(sc, table->count) - siop_cmd->resid;
877: }
878: }
879:
880: int
881: siop_iwr(siop_cmd)
882: struct siop_common_cmd *siop_cmd;
883: {
884: int offset;
885: scr_table_t *table; /* table with IWR */
886: struct siop_common_softc *sc = siop_cmd->siop_sc;
887: /* handle ignore wide residue messages */
888:
889: /* if target isn't wide, reject */
890: if ((siop_cmd->siop_target->flags & TARF_ISWIDE) == 0) {
891: siop_cmd->siop_tables->t_msgout.count = siop_htoc32(sc, 1);
892: siop_cmd->siop_tables->msg_out[0] = MSG_MESSAGE_REJECT;
893: return SIOP_NEG_MSGOUT;
894: }
895: /* get index of current command in table */
896: offset = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCRATCHA + 1);
897: /*
898: * if the current table did complete, we're now pointing at the
899: * next one. Go back one if we didn't see a phase mismatch.
900: */
901: if ((siop_cmd->flags & CMDFL_RESID) == 0)
902: offset--;
903: table = &siop_cmd->siop_tables->data[offset];
904:
905: if ((siop_cmd->flags & CMDFL_RESID) == 0) {
906: if (siop_ctoh32(sc, table->count) & 1) {
907: /* we really got the number of bytes we expected */
908: return SIOP_NEG_ACK;
909: } else {
910: /*
911: * now we really had a short xfer, by one byte.
912: * handle it just as if we had a phase mistmatch
913: * (there is a resid of one for this table).
914: * Update scratcha1 to reflect the fact that
915: * this xfer isn't complete.
916: */
917: siop_cmd->flags |= CMDFL_RESID;
918: siop_cmd->resid = 1;
919: bus_space_write_1(sc->sc_rt, sc->sc_rh,
920: SIOP_SCRATCHA + 1, offset);
921: return SIOP_NEG_ACK;
922: }
923: } else {
924: /*
925: * we already have a short xfer for this table; it's
926: * just one byte less than we though it was
927: */
928: siop_cmd->resid--;
929: return SIOP_NEG_ACK;
930: }
931: }
932:
933: void
934: siop_clearfifo(sc)
935: struct siop_common_softc *sc;
936: {
937: int timeout = 0;
938: int ctest3 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3);
939:
940: #ifdef DEBUG_INTR
941: printf("DMA fifo not empty !\n");
942: #endif
943: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
944: ctest3 | CTEST3_CLF);
945: while ((bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3) &
946: CTEST3_CLF) != 0) {
947: delay(1);
948: if (++timeout > 1000) {
949: printf("clear fifo failed\n");
950: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_CTEST3,
951: bus_space_read_1(sc->sc_rt, sc->sc_rh,
952: SIOP_CTEST3) & ~CTEST3_CLF);
953: return;
954: }
955: }
956: }
957:
958: int
959: siop_modechange(sc)
960: struct siop_common_softc *sc;
961: {
962: int retry;
963: int sist0, sist1, stest2;
964: for (retry = 0; retry < 5; retry++) {
965: /*
966: * datasheet says to wait 100ms and re-read SIST1,
967: * to check that DIFFSENSE is stable.
968: * We may delay() 5 times for 100ms at interrupt time;
969: * hopefully this will not happen often.
970: */
971: delay(100000);
972: sist0 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST0);
973: sist1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SIST1);
974: if (sist1 & SIEN1_SBMC)
975: continue; /* we got an irq again */
976: sc->mode = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST4) &
977: STEST4_MODE_MASK;
978: stest2 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2);
979: switch(sc->mode) {
980: case STEST4_MODE_DIF:
981: printf("%s: switching to differential mode\n",
982: sc->sc_dev.dv_xname);
983: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
984: stest2 | STEST2_DIF);
985: break;
986: case STEST4_MODE_SE:
987: printf("%s: switching to single-ended mode\n",
988: sc->sc_dev.dv_xname);
989: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
990: stest2 & ~STEST2_DIF);
991: break;
992: case STEST4_MODE_LVD:
993: printf("%s: switching to LVD mode\n",
994: sc->sc_dev.dv_xname);
995: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_STEST2,
996: stest2 & ~STEST2_DIF);
997: break;
998: default:
999: printf("%s: invalid SCSI mode 0x%x\n",
1000: sc->sc_dev.dv_xname, sc->mode);
1001: return 0;
1002: }
1003: return 1;
1004: }
1005: printf("%s: timeout waiting for DIFFSENSE to stabilise\n",
1006: sc->sc_dev.dv_xname);
1007: return 0;
1008: }
1009:
1010: void
1011: siop_resetbus(sc)
1012: struct siop_common_softc *sc;
1013: {
1014: int scntl1;
1015: scntl1 = bus_space_read_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1);
1016: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1,
1017: scntl1 | SCNTL1_RST);
1018: /* minimum 25 us, more time won't hurt */
1019: delay(100);
1020: bus_space_write_1(sc->sc_rt, sc->sc_rh, SIOP_SCNTL1, scntl1);
1021: }
1022:
1023: void
1024: siop_update_xfer_mode(sc, target)
1025: struct siop_common_softc *sc;
1026: int target;
1027: {
1028: struct siop_common_target *siop_target;
1029:
1030: siop_target = sc->targets[target];
1031:
1032: printf("%s: target %d now using %s%s%d bit ",
1033: sc->sc_dev.dv_xname, target,
1034: (siop_target->flags & TARF_TAG) ? "tagged " : "",
1035: (siop_target->flags & TARF_ISDT) ? "DT " : "",
1036: (siop_target->flags & TARF_ISWIDE) ? 16 : 8);
1037:
1038: if (siop_target->offset == 0)
1039: printf("async ");
1040: else {
1041: switch (siop_target->period) {
1042: case 9: /* 12.5ns cycle */
1043: printf("80.0");
1044: break;
1045: case 10: /* 25 ns cycle */
1046: printf("40.0");
1047: break;
1048: case 12: /* 48 ns cycle */
1049: printf("20.0");
1050: break;
1051: case 18: /* 72 ns cycle */
1052: printf("13.3");
1053: break;
1054: case 25: /* 100 ns cycle */
1055: printf("10.0");
1056: break;
1057: case 37: /* 118 ns cycle */
1058: printf("6.67");
1059: break;
1060: case 50: /* 200 ns cycle */
1061: printf("5.0");
1062: break;
1063: case 75: /* 300 ns cycle */
1064: printf("3.33");
1065: break;
1066: default:
1067: printf("??");
1068: break;
1069: }
1070: printf(" MHz %d REQ/ACK offset ", siop_target->offset);
1071: }
1072:
1073: printf("xfers\n");
1074:
1075: if ((sc->features & SF_CHIP_GEBUG) &&
1076: (siop_target->flags & TARF_ISWIDE) == 0)
1077: /* 1010 workaround: can't do disconnect if not wide, so can't do tag */
1078: siop_target->flags &= ~TARF_TAG;
1079: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to siop_common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic