![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rz_cpu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / scsi|
Return to rz_cpu.c CVS log | Up to [GnuMach] / Gnu-Mach / scsi |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * File: rz_cpu.c
28: * Author: Alessandro Forin, Carnegie Mellon University
29: * Date: 7/91
30: *
31: * Top layer of the SCSI driver: interface with the MI.
32: * This file contains operations specific to CPU-like devices.
33: *
34: * We handle here the case of simple devices which do not use any
35: * sophisticated host-to-host communication protocol, they look
36: * very much like degenerative cases of TAPE devices.
37: *
38: * For documentation and debugging, we also provide code to act like one.
39: */
40:
41: #include <mach/std_types.h>
42: #include <scsi/compat_30.h>
43:
44: #include <scsi/scsi.h>
45: #include <scsi/scsi_defs.h>
46: #include <scsi/rz.h>
47:
48: #if (NSCSI > 0)
49:
50: void sccpu_act_as_target(); /* forwards */
51: void sccpu_start();
52:
53: /*
54: * This function decides which 'protocol' we well speak
55: * to a cpu target. For now the decision is left to a
56: * global var. XXXXXXX
57: */
58: extern scsi_devsw_t scsi_host;
59: scsi_devsw_t *scsi_cpu_protocol = /* later &scsi_host*/
60: &scsi_devsw[SCSI_CPU];
61:
62: void sccpu_new_initiator(self, initiator)
63: target_info_t *self, *initiator;
64: {
65: initiator->dev_ops = scsi_cpu_protocol;
66: if (initiator == self) {
67: self->flags = TGT_DID_SYNCH|TGT_FULLY_PROBED|TGT_ONLINE|
68: TGT_ALIVE|TGT_US;
69: self->dev_info.cpu.req_pending = FALSE;
70: } else {
71: initiator->flags = TGT_ONLINE|TGT_ALIVE;
72: initiator->dev_info.cpu.req_pending = TRUE;
73: }
74: }
75:
76: void sccpu_strategy(ior)
77: register io_req_t ior;
78: {
79: void sccpu_start();
80:
81: rz_simpleq_strategy(ior, sccpu_start);
82: }
83:
84: void sccpu_start(tgt, done)
85: target_info_t *tgt;
86: boolean_t done;
87: {
88: io_req_t head, ior;
89: scsi_ret_t ret;
90:
91: /* this is to the doc & debug code mentioned in the beginning */
92: if (!done && tgt->dev_info.cpu.req_pending) {
93: panic("sccpu_act_as_target called");
94: #if 0
95: sccpu_act_as_target( tgt);
96: #endif
97: return;
98: }
99:
100: ior = tgt->ior;
101: if (ior == 0)
102: return;
103:
104: if (done) {
105:
106: /* see if we must retry */
107: if ((tgt->done == SCSI_RET_RETRY) &&
108: ((ior->io_op & IO_INTERNAL) == 0)) {
109: delay(1000000);/*XXX*/
110: goto start;
111: } else
112: /* got a bus reset ? shouldn't matter */
113: if ((tgt->done == (SCSI_RET_ABORTED|SCSI_RET_RETRY)) &&
114: ((ior->io_op & IO_INTERNAL) == 0)) {
115: goto start;
116: } else
117:
118: /* check completion status */
119:
120: if (tgt->cur_cmd == SCSI_CMD_REQUEST_SENSE) {
121: scsi_sense_data_t *sns;
122:
123: ior->io_op = ior->io_temporary;
124: ior->io_error = D_IO_ERROR;
125: ior->io_op |= IO_ERROR;
126:
127: sns = (scsi_sense_data_t *)tgt->cmd_ptr;
128: if (scsi_debug)
129: scsi_print_sense_data(sns);
130:
131: if (scsi_check_sense_data(tgt, sns)) {
132: if (sns->u.xtended.ili) {
133: if (ior->io_op & IO_READ) {
134: int residue;
135:
136: residue = sns->u.xtended.info0 << 24 |
137: sns->u.xtended.info1 << 16 |
138: sns->u.xtended.info2 << 8 |
139: sns->u.xtended.info3;
140: if (scsi_debug)
141: printf("Cpu Short Read (%d)\n", residue);
142: /*
143: * NOTE: residue == requested - actual
144: * We only care if > 0
145: */
146: if (residue < 0) residue = 0;/* sanity */
147: ior->io_residual += residue;
148: ior->io_error = 0;
149: ior->io_op &= ~IO_ERROR;
150: /* goto ok */
151: }
152: }
153: }
154: }
155:
156: else if (tgt->done != SCSI_RET_SUCCESS) {
157:
158: if (tgt->done == SCSI_RET_NEED_SENSE) {
159:
160: ior->io_temporary = ior->io_op;
161: ior->io_op = IO_INTERNAL;
162: if (scsi_debug)
163: printf("[NeedSns x%x x%x]", ior->io_residual, ior->io_count);
164: scsi_request_sense(tgt, ior, 0);
165: return;
166:
167: } else if (tgt->done == SCSI_RET_RETRY) {
168: /* only retry here READs and WRITEs */
169: if ((ior->io_op & IO_INTERNAL) == 0) {
170: ior->io_residual = 0;
171: goto start;
172: } else{
173: ior->io_error = D_WOULD_BLOCK;
174: ior->io_op |= IO_ERROR;
175: }
176: } else {
177: ior->io_error = D_IO_ERROR;
178: ior->io_op |= IO_ERROR;
179: }
180: }
181:
182: if (scsi_debug)
183: printf("[Resid x%x]", ior->io_residual);
184:
185: /* dequeue next one */
186: head = ior;
187:
188: simple_lock(&tgt->target_lock);
189: ior = head->io_next;
190: tgt->ior = ior;
191: if (ior)
192: ior->io_prev = head->io_prev;
193: simple_unlock(&tgt->target_lock);
194:
195: iodone(head);
196:
197: if (ior == 0)
198: return;
199: }
200: ior->io_residual = 0;
201: start:
202: if (ior->io_op & IO_READ) {
203: ret = scsi_receive( tgt, ior );
204: } else if ((ior->io_op & IO_INTERNAL) == 0) {
205: ret = scsi_send( tgt, ior );
206: }
207: }
208:
209:
210: #if 0
211: /* XX turned off this code because it's impossible
212: to reference 'end' and other such magic symbols
213: from boot modules. */
214: /*
215: * This is a simple code to make us act as a dumb
216: * processor type. Use for debugging only.
217: */
218: static struct io_req sccpu_ior;
219: vm_offset_t sccpu_buffer; /* set this with debugger */
220:
221: void sccpu_act_as_target(self)
222: target_info_t *self;
223: {
224: static char inq_data[] = "\3\0\1\0\040\0\0\0Mach3.0 Processor Link v0.1";
225: static char sns_data[] = "\160\0\0\0\0\0\0\0\0";
226:
227: self->dev_info.cpu.req_pending = FALSE;
228: sccpu_ior.io_next = 0;
229: #define MAXSIZE 1024*64
230: sccpu_ior.io_count = (MAXSIZE < self->dev_info.cpu.req_len) ?
231: MAXSIZE : self->dev_info.cpu.req_len;
232:
233: switch (self->dev_info.cpu.req_cmd) {
234: case SCSI_CMD_INQUIRY:
235: sccpu_ior.io_data = inq_data; break;
236: case SCSI_CMD_REQUEST_SENSE:
237: sccpu_ior.io_data = sns_data; break;
238: default:
239: if (sccpu_buffer == 0) {
240: /* ( read my lips :-) */
241: /* extern char end[]; */
242: sccpu_buffer = trunc_page(kalloc(MAXSIZE));
243: }
244: sccpu_ior.io_data = (char*)sccpu_buffer; break;
245: }
246:
247: if (self->dev_info.cpu.req_cmd == SCSI_CMD_SEND) {
248: self->cur_cmd = SCSI_CMD_READ;
249: sccpu_ior.io_op = IO_READ;
250: } else {
251: self->cur_cmd = SCSI_CMD_WRITE;
252: sccpu_ior.io_op = IO_WRITE;
253: }
254: self->ior = &sccpu_ior;
255: }
256: #endif
257:
258: /*#define PERF*/
259: #ifdef PERF
260: int test_read_size = 512;
261: int test_read_nreads = 1000;
262: int test_read_bdev = 0;
263: int test_read_or_write = 1;
264:
265: #include <sys/time.h>
266: #include <machine/machspl.h> /* spl */
267:
268: test_read(max)
269: {
270: int i, ssk, usecs;
271: struct timeval start, stop;
272: spl_t s;
273:
274: if (max != 0)
275: test_read_nreads = max;
276:
277: s = spl0();
278: start = time;
279: if (test_read_or_write) read_test(); else write_test();
280: stop = time;
281: splx(s);
282:
283: usecs = stop.tv_usec - start.tv_usec;
284: if (usecs < 0) {
285: stop.tv_sec -= 1;
286: usecs += 1000000;
287: }
288: printf("Size %d count %d time %3d sec %d us\n",
289: test_read_size, test_read_nreads,
290: stop.tv_sec - start.tv_sec, usecs);
291: }
292:
293: read_test()
294: {
295: struct io_req io, io1;
296: register int i;
297:
298: bzero(&io, sizeof(io));
299: io.io_unit = test_read_bdev;
300: io.io_op = IO_READ;
301: io.io_count = test_read_size;
302: io.io_data = (char*)sccpu_buffer;
303: io1 = io;
304:
305: sccpu_strategy(&io);
306: for (i = 1; i < test_read_nreads; i += 2) {
307: io1.io_op = IO_READ;
308: sccpu_strategy(&io1);
309: iowait(&io);
310: io.io_op = IO_READ;
311: sccpu_strategy(&io);
312: iowait(&io1);
313: }
314: iowait(&io);
315: }
316:
317: write_test()
318: {
319: struct io_req io, io1;
320: register int i;
321:
322: bzero(&io, sizeof(io));
323: io.io_unit = test_read_bdev;
324: io.io_op = IO_WRITE;
325: io.io_count = test_read_size;
326: io.io_data = (char*)sccpu_buffer;
327: io1 = io;
328:
329: sccpu_strategy(&io);
330: for (i = 1; i < test_read_nreads; i += 2) {
331: io1.io_op = IO_WRITE;
332: sccpu_strategy(&io1);
333: iowait(&io);
334: io.io_op = IO_WRITE;
335: sccpu_strategy(&io);
336: iowait(&io1);
337: }
338: iowait(&io);
339: }
340:
341: tur_test()
342: {
343: struct io_req io;
344: register int i;
345: char *a;
346: struct timeval start, stop;
347: spl_t s;
348: target_info_t *tgt;
349:
350: bzero(&io, sizeof(io));
351: io.io_unit = test_read_bdev;
352: io.io_data = (char*)&io;/*unused but kernel space*/
353:
354: rz_check(io.io_unit, &a, &tgt);
355: s = spl0();
356: start = time;
357: for (i = 0; i < test_read_nreads; i++) {
358: io.io_op = IO_INTERNAL;
359: scsi_test_unit_ready(tgt,&io);
360: }
361: stop = time;
362: splx(s);
363: i = stop.tv_usec - start.tv_usec;
364: if (i < 0) {
365: stop.tv_sec -= 1;
366: i += 1000000;
367: }
368: printf("%d test-unit-ready took %3d sec %d us\n",
369: test_read_nreads,
370: stop.tv_sec - start.tv_sec, i);
371: }
372:
373: /*#define MEM_PERF*/
374: #ifdef MEM_PERF
375: int mem_read_size = 1024; /* ints! */
376: int mem_read_nreads = 1000;
377: volatile int *mem_read_address = (volatile int*)0xb0080000;
378: volatile int *mem_write_address = (volatile int*)0xb0081000;
379:
380: mem_test(max, which)
381: {
382: int i, ssk, usecs;
383: struct timeval start, stop;
384: int (*fun)(), mwrite_test(), mread_test(), mcopy_test();
385: spl_t s;
386:
387: if (max == 0)
388: max = mem_read_nreads;
389:
390: switch (which) {
391: case 1: fun = mwrite_test; break;
392: case 2: fun = mcopy_test; break;
393: default:fun = mread_test; break;
394: }
395:
396: s = spl0();
397: start = time;
398: for (i = 0; i < max; i++)
399: (*fun)(mem_read_size);
400: stop = time;
401: splx(s);
402:
403: usecs = stop.tv_usec - start.tv_usec;
404: if (usecs < 0) {
405: stop.tv_sec -= 1;
406: usecs += 1000000;
407: }
408: printf("Size %d count %d time %3d sec %d us\n",
409: mem_read_size*4, max,
410: stop.tv_sec - start.tv_sec, usecs);
411: }
412:
413: mread_test(max)
414: register int max;
415: {
416: register int i;
417: register volatile int *addr = mem_read_address;
418:
419: for (i = 0; i < max; i++) {
420: register int j = *addr++;
421: }
422: }
423: mwrite_test(max)
424: register int max;
425: {
426: register int i;
427: register volatile int *addr = mem_read_address;
428:
429: for (i = 0; i < max; i++) {
430: *addr++ = i;
431: }
432: }
433:
434: mcopy_test(max)
435: register int max;
436: {
437: register volatile int *from = mem_read_address;
438: register volatile int *to = mem_write_address;
439: register volatile int *endaddr;
440:
441: endaddr = to + max;
442: while (to < endaddr)
443: *to++ = *from++;
444:
445: }
446: #endif /*MEM_PERF*/
447:
448: #endif /*PERF*/
449:
450: #endif /* NSCSI > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.