![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi_disk.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 scsi_disk.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: scsi_disk.c
28: * Author: Alessandro Forin, Carnegie Mellon University
29: * Date: 10/90
30: *
31: * Middle layer of the SCSI driver: SCSI protocol implementation
32: *
33: * This file contains code for SCSI commands for DISK devices.
34: */
35:
36: #include <string.h>
37:
38: #include <mach/std_types.h>
39: #include <scsi/compat_30.h>
40:
41: #include <scsi/scsi.h>
42: #include <scsi/scsi2.h>
43: #include <scsi/scsi_defs.h>
44:
45: #if (NSCSI > 0)
46:
47:
48: char *scdisk_name(internal)
49: boolean_t internal;
50: {
51: return internal ? "rz" : "disk";
52: }
53:
54: /*
55: * SCSI commands partially specific to disks
56: */
57: void scdisk_read( tgt, secno, ior)
58: register target_info_t *tgt;
59: register unsigned int secno;
60: io_req_t ior;
61: {
62: scsi_cmd_read_t *cmd;
63: register unsigned len;
64: unsigned int max_dma_data;
65:
66: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
67:
68: len = ior->io_count;
69: if (len > max_dma_data)
70: len = max_dma_data;
71: if (len < tgt->block_size)
72: len = tgt->block_size;
73:
74: cmd = (scsi_cmd_read_t*) (tgt->cmd_ptr);
75: cmd->scsi_cmd_code = SCSI_CMD_READ;
76: cmd->scsi_cmd_lun_and_lba1 = (secno>>16)&SCSI_LBA_MASK;
77: cmd->scsi_cmd_lba2 = (secno>> 8)&0xff;
78: cmd->scsi_cmd_lba3 = (secno )&0xff;
79: cmd->scsi_cmd_xfer_len = len / tgt->block_size;
80: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
81:
82: tgt->cur_cmd = SCSI_CMD_READ;
83:
84: scsi_go(tgt, sizeof(*cmd), len, FALSE);
85: }
86:
87: void scdisk_write( tgt, secno, ior)
88: register target_info_t *tgt;
89: register unsigned int secno;
90: io_req_t ior;
91: {
92: scsi_cmd_write_t *cmd;
93: unsigned len; /* in bytes */
94: unsigned int max_dma_data;
95:
96: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
97:
98: len = ior->io_count;
99: if (len > max_dma_data)
100: len = max_dma_data;
101: if (len < tgt->block_size)
102: len = tgt->block_size;
103:
104: cmd = (scsi_cmd_write_t*) (tgt->cmd_ptr);
105: cmd->scsi_cmd_code = SCSI_CMD_WRITE;
106: cmd->scsi_cmd_lun_and_lba1 = (secno>>16)&SCSI_LBA_MASK;
107: cmd->scsi_cmd_lba2 = (secno>> 8)&0xff;
108: cmd->scsi_cmd_lba3 = (secno )&0xff;
109: cmd->scsi_cmd_xfer_len = len / tgt->block_size;
110: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
111:
112: tgt->cur_cmd = SCSI_CMD_WRITE;
113:
114: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
115: }
116:
117:
118: int scdisk_mode_select(tgt, lbn, ior, mdata, mlen, save)
119: register target_info_t *tgt;
120: register int lbn;
121: io_req_t ior;
122: char *mdata;
123: int mlen, save;
124: {
125: scsi_cmd_mode_select_t *cmd;
126: scsi_mode_select_param_t *parm;
127:
128: bzero(tgt->cmd_ptr, sizeof(*cmd) + sizeof(*parm));
129: cmd = (scsi_cmd_mode_select_t*) (tgt->cmd_ptr);
130: cmd->scsi_cmd_code = SCSI_CMD_MODE_SELECT;
131: cmd->scsi_cmd_lun_and_lba1 = SCSI_CMD_MSL_PF; /* XXX only if... */
132: cmd->scsi_cmd_xfer_len = sizeof(scsi_mode_select_param_t);/* no vuq */
133:
134: parm = (scsi_mode_select_param_t*) (cmd + 1);
135: if (mdata) {
136: cmd->scsi_cmd_xfer_len = mlen;
137: bcopy(mdata, (char*)parm, mlen);
138: if (save)
139: cmd->scsi_cmd_lun_and_lba1 |= SCSI_CMD_MSL_SP;
140: } else {
141: /* parm->medium_type = if (floppy)disk.. */
142: parm->desc_len = 8;
143: /* this really is the LBN */
144: parm->descs[0].density_code = 0;/* XXX default XXX */
145: parm->descs[0].reclen1 = (lbn>>16)&0xff;
146: parm->descs[0].reclen2 = (lbn>> 8)&0xff;
147: parm->descs[0].reclen3 = (lbn )&0xff;
148: mlen = sizeof(*parm);
149: }
150:
151: tgt->cur_cmd = SCSI_CMD_MODE_SELECT;
152:
153: scsi_go_and_wait(tgt, sizeof(*cmd) + mlen, 0, ior);
154:
155: return tgt->done;
156: }
157:
158: /*
159: * SCSI commands fully specific to disks
160: */
161: int scsi_read_capacity( tgt, lbn, ior)
162: register target_info_t *tgt;
163: int lbn;
164: io_req_t ior;
165: {
166: scsi_cmd_read_capacity_t *cmd;
167:
168: bzero(tgt->cmd_ptr, sizeof(*cmd));
169: cmd = (scsi_cmd_read_capacity_t*) (tgt->cmd_ptr);
170: cmd->scsi_cmd_code = SCSI_CMD_READ_CAPACITY;
171: /* all zeroes, unless... */
172: if (lbn) {
173: cmd->scsi_cmd_rcap_flags = SCSI_CMD_RCAP_PMI;
174: cmd->scsi_cmd_lba1 = (lbn>>24);
175: cmd->scsi_cmd_lba2 = (lbn>>16)&0xff;
176: cmd->scsi_cmd_lba3 = (lbn>> 8)&0xff;
177: cmd->scsi_cmd_lba4 = (lbn )&0xff;
178: }
179:
180: tgt->cur_cmd = SCSI_CMD_READ_CAPACITY;
181:
182: scsi_go_and_wait(tgt, sizeof(*cmd), sizeof(scsi_rcap_data_t),ior);
183:
184: return tgt->done;
185: }
186:
187: void scsi_reassign_blocks( tgt, defect_list, n_defects, ior)
188: register target_info_t *tgt;
189: unsigned int *defect_list; /* In ascending order ! */
190: int n_defects;
191: io_req_t ior;
192: {
193: scsi_cmd_reassign_blocks_t *cmd;
194: scsi_Ldefect_data_t *parm;
195:
196: cmd = (scsi_cmd_reassign_blocks_t*) (tgt->cmd_ptr);
197: cmd->scsi_cmd_code = SCSI_CMD_REASSIGN_BLOCKS;
198: cmd->scsi_cmd_lun_and_lba1 = 0;
199: cmd->scsi_cmd_lba2 = 0;
200: cmd->scsi_cmd_lba3 = 0;
201: cmd->scsi_cmd_xfer_len = 0;
202: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
203:
204: parm = (scsi_Ldefect_data_t *) (cmd + 1);
205: parm->res1 = parm->res2 = 0;
206: n_defects *= 4; /* in 4-byte-ints */
207: parm->list_len_msb = n_defects >> 8;
208: parm->list_len_lsb = n_defects;
209: bcopy((char*)defect_list, (char*)parm->defects, n_defects);
210:
211: tgt->cur_cmd = SCSI_CMD_REASSIGN_BLOCKS;
212:
213: scsi_go(tgt, sizeof(*cmd) + sizeof(*parm) + (n_defects - 4), 0, FALSE);
214: }
215:
216: void scsi_medium_removal( tgt, allow, ior)
217: register target_info_t *tgt;
218: boolean_t allow;
219: io_req_t ior;
220: {
221: scsi_cmd_medium_removal_t *cmd;
222:
223: cmd = (scsi_cmd_medium_removal_t*) (tgt->cmd_ptr);
224: cmd->scsi_cmd_code = SCSI_CMD_PREVENT_ALLOW_REMOVAL;
225: cmd->scsi_cmd_lun_and_lba1 = 0;
226: cmd->scsi_cmd_lba2 = 0;
227: cmd->scsi_cmd_lba3 = 0;
228: cmd->scsi_cmd_pa_prevent = allow ? 0 : 1;
229: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
230:
231:
232: tgt->cur_cmd = SCSI_CMD_PREVENT_ALLOW_REMOVAL;
233:
234: scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
235: }
236:
237: int scsi_format_unit( tgt, mode, vuqe, intlv, ior)
238: register target_info_t *tgt;
239: int mode, vuqe;
240: register unsigned int intlv;
241: io_req_t ior;
242: {
243: scsi_cmd_format_t *cmd;
244: char *parms;
245:
246: cmd = (scsi_cmd_format_t*) (tgt->cmd_ptr);
247: cmd->scsi_cmd_code = SCSI_CMD_FORMAT_UNIT;
248: cmd->scsi_cmd_lun_and_lba1 =
249: mode & (SCSI_CMD_FMT_FMTDATA|SCSI_CMD_FMT_CMPLIST|SCSI_CMD_FMT_LIST_TYPE);
250: cmd->scsi_cmd_lba2 = vuqe;
251: cmd->scsi_cmd_lba3 = intlv >> 8;
252: cmd->scsi_cmd_xfer_len = intlv;
253: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
254:
255: parms = (char*) cmd + 1;
256: if (ior->io_count)
257: bcopy(ior->io_data, parms, ior->io_count);
258: else
259: bzero(parms, 0xff - sizeof(*cmd));
260:
261: tgt->cur_cmd = SCSI_CMD_FORMAT_UNIT;
262:
263: scsi_go_and_wait(tgt, sizeof(*cmd) + ior->io_count, 0, ior);
264: return tgt->done;
265: }
266:
267:
268: /* Group 1 Commands */
269:
270: void scsi_long_read( tgt, secno, ior)
271: register target_info_t *tgt;
272: register unsigned int secno;
273: io_req_t ior;
274: {
275: scsi_cmd_long_read_t *cmd;
276: register unsigned len, n_blks;
277: unsigned int max_dma_data;
278:
279: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
280:
281: len = ior->io_count;
282: if (len > max_dma_data)
283: len = max_dma_data;
284: if (len < tgt->block_size)
285: len = tgt->block_size;
286: n_blks = len /tgt->block_size;
287:
288: cmd = (scsi_cmd_long_read_t*) (tgt->cmd_ptr);
289: cmd->scsi_cmd_code = SCSI_CMD_LONG_READ;
290: cmd->scsi_cmd_lun_and_relbit = 0;
291: cmd->scsi_cmd_lba1 = secno >> 24;
292: cmd->scsi_cmd_lba2 = secno >> 16;
293: cmd->scsi_cmd_lba3 = secno >> 8;
294: cmd->scsi_cmd_lba4 = secno;
295: cmd->scsi_cmd_xxx = 0;
296: cmd->scsi_cmd_xfer_len_1 = n_blks >> 8;
297: cmd->scsi_cmd_xfer_len_2 = n_blks;
298: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
299:
300: tgt->cur_cmd = SCSI_CMD_LONG_READ;
301:
302: scsi_go(tgt, sizeof(*cmd), len, FALSE);
303: }
304:
305: void scsi_long_write( tgt, secno, ior)
306: register target_info_t *tgt;
307: register unsigned int secno;
308: io_req_t ior;
309: {
310: scsi_cmd_long_write_t *cmd;
311: unsigned len; /* in bytes */
312: unsigned int max_dma_data, n_blks;
313:
314: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
315:
316: len = ior->io_count;
317: if (len > max_dma_data)
318: len = max_dma_data;
319: if (len < tgt->block_size)
320: len = tgt->block_size;
321: n_blks = len /tgt->block_size;
322:
323: cmd = (scsi_cmd_long_write_t*) (tgt->cmd_ptr);
324: cmd->scsi_cmd_code = SCSI_CMD_LONG_WRITE;
325: cmd->scsi_cmd_lun_and_relbit = 0;
326: cmd->scsi_cmd_lba1 = secno >> 24;
327: cmd->scsi_cmd_lba2 = secno >> 16;
328: cmd->scsi_cmd_lba3 = secno >> 8;
329: cmd->scsi_cmd_lba4 = secno;
330: cmd->scsi_cmd_xxx = 0;
331: cmd->scsi_cmd_xfer_len_1 = n_blks >> 8;
332: cmd->scsi_cmd_xfer_len_2 = n_blks;
333: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
334:
335: tgt->cur_cmd = SCSI_CMD_LONG_WRITE;
336:
337: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
338: }
339:
340: int scdisk_verify( tgt, secno, nsectrs, ior)
341: register target_info_t *tgt;
342: int secno, nsectrs;
343: io_req_t ior;
344: {
345: scsi_cmd_verify_long_t *cmd;
346: int len;
347:
348: len = ior->io_count;
349:
350: cmd = (scsi_cmd_verify_long_t*) (tgt->cmd_ptr);
351: cmd->scsi_cmd_code = SCSI_CMD_VERIFY_1;
352: cmd->scsi_cmd_lun_and_relbit = len ? SCSI_CMD_VFY_BYTCHK : 0;
353: cmd->scsi_cmd_lba1 = secno >> 24;
354: cmd->scsi_cmd_lba2 = secno >> 16;
355: cmd->scsi_cmd_lba3 = secno >> 8;
356: cmd->scsi_cmd_lba4 = secno;
357: cmd->scsi_cmd_xxx = 0;
358: cmd->scsi_cmd_xfer_len_1 = (nsectrs) >> 8;
359: cmd->scsi_cmd_xfer_len_2 = nsectrs;
360: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
361:
362: tgt->cur_cmd = SCSI_CMD_VERIFY_1;
363:
364: scsi_go_and_wait(tgt, sizeof(*cmd) + len, 0, ior);
365: return tgt->done;
366: }
367:
368:
369: int scsi_read_defect( tgt, mode, ior)
370: register target_info_t *tgt;
371: register unsigned int mode;
372: io_req_t ior;
373: {
374: scsi_cmd_long_read_t *cmd;
375: register unsigned len;
376:
377: len = ior->io_count;
378: if (len > 0xffff)
379: len = 0xffff;
380:
381: cmd = (scsi_cmd_read_defect_t*) (tgt->cmd_ptr);
382: cmd->scsi_cmd_code = SCSI_CMD_READ_DEFECT_DATA;
383: cmd->scsi_cmd_lun_and_relbit = 0;
384: cmd->scsi_cmd_lba1 = mode & 0x1f;
385: cmd->scsi_cmd_lba2 = 0;
386: cmd->scsi_cmd_lba3 = 0;
387: cmd->scsi_cmd_lba4 = 0;
388: cmd->scsi_cmd_xxx = 0;
389: cmd->scsi_cmd_xfer_len_1 = (len) >> 8;
390: cmd->scsi_cmd_xfer_len_2 = (len);
391: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
392:
393: /* ++ HACK Alert */
394: /* tgt->cur_cmd = SCSI_CMD_READ_DEFECT_DATA;*/
395: tgt->cur_cmd = SCSI_CMD_LONG_READ;
396: /* -- HACK Alert */
397:
398: scsi_go(tgt, sizeof(*cmd), len, FALSE);
399: iowait(ior);
400: return tgt->done;
401: }
402:
403:
404: #if 0 /* unused commands */
405: scsi_rezero_unit( tgt, ior)
406: register target_info_t *tgt;
407: io_req_t ior;
408: {
409: scsi_cmd_rezero_t *cmd;
410:
411: cmd = (scsi_cmd_rezero_t*) (tgt->cmd_ptr);
412: cmd->scsi_cmd_code = SCSI_CMD_REZERO_UNIT;
413: cmd->scsi_cmd_lun_and_lba1 = 0;
414: cmd->scsi_cmd_lba2 = 0;
415: cmd->scsi_cmd_lba3 = 0;
416: cmd->scsi_cmd_xfer_len = 0;
417: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
418:
419:
420: tgt->cur_cmd = SCSI_CMD_REZERO_UNIT;
421:
422: scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
423:
424: }
425:
426: scsi_seek( tgt, where, ior)
427: register target_info_t *tgt;
428: register unsigned int where;
429: io_req_t ior;
430: {
431: scsi_cmd_seek_t *cmd;
432:
433: cmd = (scsi_cmd_seek_t*) (tgt->cmd_ptr);
434: cmd->scsi_cmd_code = SCSI_CMD_SEEK;
435: cmd->scsi_cmd_lun_and_lba1 = (where >> 16) & 0x1f;
436: cmd->scsi_cmd_lba2 = where >> 8;
437: cmd->scsi_cmd_lba3 = where;
438: cmd->scsi_cmd_xfer_len = 0;
439: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
440:
441:
442: tgt->cur_cmd = SCSI_CMD_SEEK;
443:
444: scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
445:
446: }
447:
448: scsi_reserve( tgt, len, id, mode, ior)
449: register target_info_t *tgt;
450: register unsigned int len;
451: unsigned char id;
452: io_req_t ior;
453: {
454: scsi_cmd_reserve_t *cmd;
455:
456: cmd = (scsi_cmd_reserve_t*) (tgt->cmd_ptr);
457: cmd->scsi_cmd_code = SCSI_CMD_RESERVE;
458: cmd->scsi_cmd_lun_and_lba1 = mode & 0x1f;
459: cmd->scsi_cmd_reserve_id = id;
460: cmd->scsi_cmd_extent_llen1 = len >> 8;
461: cmd->scsi_cmd_extent_llen2 = len;
462: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
463:
464:
465: tgt->cur_cmd = SCSI_CMD_RESERVE;
466:
467: scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
468:
469: }
470:
471: scsi_release( tgt, id, mode, ior)
472: register target_info_t *tgt;
473: unsigned char id, mode;
474: io_req_t ior;
475: {
476: scsi_cmd_release_t *cmd;
477:
478: cmd = (scsi_cmd_release_t*) (tgt->cmd_ptr);
479: cmd->scsi_cmd_code = SCSI_CMD_RELEASE;
480: cmd->scsi_cmd_lun_and_lba1 = mode & 0x1f;
481: cmd->scsi_cmd_reserve_id = id;
482: cmd->scsi_cmd_lba3 = 0;
483: cmd->scsi_cmd_xfer_len = 0;
484: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
485:
486:
487: tgt->cur_cmd = SCSI_CMD_RELEASE;
488:
489: scsi_go_and_wait(tgt, sizeof(*cmd), 0, ior);
490:
491: }
492:
493:
494: /* Group 1 Commands */
495:
496: scsi_long_seek( tgt, secno, ior)
497: register target_info_t *tgt;
498: io_req_t ior;
499: {
500: scsi_cmd_long_seek_t *cmd;
501:
502: cmd = (scsi_cmd_long_seek_t*) (tgt->cmd_ptr);
503: cmd->scsi_cmd_code = SCSI_CMD_LONG_SEEK;
504: cmd->scsi_cmd_lun_and_relbit = 0;
505: cmd->scsi_cmd_lba1 = secno >> 24;
506: cmd->scsi_cmd_lba2 = secno >> 16;
507: cmd->scsi_cmd_lba3 = secno >> 8;
508: cmd->scsi_cmd_lba4 = secno;
509: cmd->scsi_cmd_xxx = 0;
510: cmd->scsi_cmd_xfer_len_1 = 0;
511: cmd->scsi_cmd_xfer_len_2 = 0;
512: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
513:
514: tgt->cur_cmd = SCSI_CMD_LONG_SEEK;
515:
516: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
517: }
518:
519: scsi_write_verify( tgt, secno, ior)
520: register target_info_t *tgt;
521: io_req_t ior;
522: {
523: scsi_cmd_write_vfy_t *cmd;
524: unsigned len; /* in bytes */
525: unsigned int max_dma_data, n_blks;
526:
527: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
528:
529: len = ior->io_count;
530: if (len > max_dma_data)
531: len = max_dma_data;
532: if (len < tgt->block_size)
533: len = tgt->block_size;
534: n_blks = len / tgt->block_size;
535:
536: cmd = (scsi_cmd_write_vfy_t*) (tgt->cmd_ptr);
537: cmd->scsi_cmd_code = SCSI_CMD_WRITE_AND_VERIFY;
538: cmd->scsi_cmd_lun_and_relbit = SCSI_CMD_VFY_BYTCHK;
539: cmd->scsi_cmd_lba1 = secno >> 24;
540: cmd->scsi_cmd_lba2 = secno >> 16;
541: cmd->scsi_cmd_lba3 = secno >> 8;
542: cmd->scsi_cmd_lba4 = secno;
543: cmd->scsi_cmd_xxx = 0;
544: cmd->scsi_cmd_xfer_len_1 = n_blks >> 8;
545: cmd->scsi_cmd_xfer_len_2 = n_blks;
546: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
547:
548: tgt->cur_cmd = SCSI_CMD_WRITE_AND_VERIFY;
549:
550: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
551: }
552:
553: scsi_search_data( tgt, secno, how, flags, ior)
554: register target_info_t *tgt;
555: io_req_t ior;
556: {
557: scsi_cmd_search_t *cmd;
558: unsigned len; /* in bytes */
559: unsigned int max_dma_data, n_blks;
560:
561: max_dma_data = scsi_softc[(unsigned char)tgt->masterno]->max_dma_data;
562:
563: if (how != SCSI_CMD_SEARCH_HIGH &&
564: how != SCSI_CMD_SEARCH_EQUAL &&
565: how != SCSI_CMD_SEARCH_LOW)
566: panic("scsi_search_data");
567:
568: len = ior->io_count;
569: if (len > max_dma_data)
570: len = max_dma_data;
571: n_blks = len / tgt->block_size;
572:
573: cmd = (scsi_cmd_search_t*) (tgt->cmd_ptr);
574: cmd->scsi_cmd_code = how;
575: cmd->scsi_cmd_lun_and_relbit = flags & 0x1e;
576: cmd->scsi_cmd_lba1 = secno >> 24;
577: cmd->scsi_cmd_lba2 = secno >> 16;
578: cmd->scsi_cmd_lba3 = secno >> 8;
579: cmd->scsi_cmd_lba4 = secno;
580: cmd->scsi_cmd_xxx = 0;
581: cmd->scsi_cmd_xfer_len_1 = n_blks >> 8;
582: cmd->scsi_cmd_xfer_len_2 = n_blks;
583: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
584:
585: tgt->cur_cmd = how;
586:
587: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
588: }
589:
590:
591: scsi_set_limits( tgt, secno, nblocks, inhibit, ior)
592: register target_info_t *tgt;
593: io_req_t ior;
594: {
595: scsi_cmd_set_limits_t *cmd;
596:
597: cmd = (scsi_cmd_set_limits_t*) (tgt->cmd_ptr);
598: cmd->scsi_cmd_code = SCSI_CMD_SET_LIMITS;
599: cmd->scsi_cmd_lun_and_relbit = inhibit & 0x3;
600: cmd->scsi_cmd_lba1 = secno >> 24;
601: cmd->scsi_cmd_lba2 = secno >> 16;
602: cmd->scsi_cmd_lba3 = secno >> 8;
603: cmd->scsi_cmd_lba4 = secno;
604: cmd->scsi_cmd_xxx = 0;
605: cmd->scsi_cmd_xfer_len_1 = nblocks >> 8;
606: cmd->scsi_cmd_xfer_len_2 = nblocks;
607: cmd->scsi_cmd_ctrl_byte = 0; /* not linked */
608:
609: tgt->cur_cmd = SCSI_CMD_SET_LIMITS;
610:
611: scsi_go(tgt, sizeof(*cmd), 0, FALSE);
612: }
613:
614:
615: #endif
616:
617: #ifdef SCSI2
618: scsi_lock_cache
619: scsi_prefetch
620: scsi_read_defect_data
621: scsi_sync_cache
622: scsi_write_same
623: #endif SCSI2
624: #endif /* NSCSI > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.