![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AtapiCnt.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / drvEIDE / EIDE.drvproj / EIDE.lksproj|
Return to AtapiCnt.m CVS log | Up to [Apple Darwin 0.x] / drvEIDE / EIDE.drvproj / EIDE.lksproj |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /*
25: * Copyright 1997-1998 by Apple Computer, Inc., All rights reserved.
26: * Copyright 1994-1997 NeXT Software, Inc., All rights reserved.
27: *
28: * AtapiCnt.m - Implementation of ATAPI controller class.
29: *
30: * HISTORY
31: *
32: * 4-Jan-1998 Joe Liu at Apple
33: * Modified the ATAPI to SCSI translation routines.
34: *
35: * 31-Aug-1994 Rakesh Dubey at NeXT
36: * Created.
37: */
38:
39: //#define DEBUG
40: //#define COMMAND_HISTORY
41: //#define COMMAND_PRINT
42:
43: #import "IdeCnt.h"
44: #import "AtapiCnt.h"
45: #import "AtapiCntInternal.h"
46: #import <kern/assert.h>
47: #import <driverkit/kernelDriver.h>
48: #import <driverkit/interruptMsg.h>
49: #import <mach/mach_interface.h>
50: #import <driverkit/IODevice.h>
51: #import <driverkit/align.h>
52: #import <machkit/NXLock.h>
53: #import <machdep/i386/io_inline.h>
54: #import <bsd/dev/scsireg.h>
55:
56: /*
57: * opcode groups
58: */
59: #define SCSI_OPGROUP(opcode) ((opcode) & 0xe0)
60:
61: #define OPGROUP_0 0x00 /* six byte commands */
62: #define OPGROUP_1 0x20 /* ten byte commands */
63: #define OPGROUP_2 0x40 /* ten byte commands */
64: #define OPGROUP_5 0xa0 /* twelve byte commands */
65: #define OPGROUP_6 0xc0 /* six byte, vendor unique commands */
66: #define OPGROUP_7 0xe0 /* ten byte, vendor unique commands */
67:
68: #ifdef undef
69: static void testDebug(id driver);
70: #endif undef
71:
72: /*
73: * List of SCSI commands that do not have a counterpart in ATAPI
74: * implementation, or commands which have different command structure.
75: * These commands will need to be specially handled.
76: */
77: #define C10OP_MODESELECT 0x55
78:
79: static unsigned char mapToAtapi[] = {
80: C6OP_MODESELECT,
81: C10OP_MODESELECT,
82: C6OP_MODESENSE
83: };
84:
85: /*
86: * List of controllers that have been already probed. We need this since each
87: * Instance table lists IdeDisk as well as IdeController classes. And we need
88: * to create instances of disks attached to each controller only once.
89: */
90: static int probedControllerCount = 0;
91: static id probedControllers[MAX_IDE_CONTROLLERS];
92:
93: @implementation AtapiController
94:
95: + (BOOL)probe : deviceDescription
96: {
97:
98: int unit, i;
99: id direct;
100: id atapiCnt;
101:
102:
103: direct = [deviceDescription directDevice];
104:
105:
106: #ifdef undef
107: IOLog("AtapiController probed with direct device %x\n", direct);
108: #endif undef
109:
110: for (i = 0; i < probedControllerCount; i++) {
111: if (probedControllers[i] == direct) {
112: {
113: #ifdef undef
114: IOLog("AtapiController already probed for controller %x\n",
115: direct);
116: #endif undef
117: return YES;
118: }
119: }
120: }
121:
122: probedControllers[probedControllerCount++] = direct;
123:
124: for (unit = 0; unit < [direct numDevices]; unit++) {
125:
126: if ([direct isAtapiDevice:unit]) {
127: atapiCnt = [[self alloc]
128: initFromDeviceDescription:deviceDescription];
129:
130: if (atapiCnt == nil) {
131: IOLog("ATAPI: failed to probe device %d.\n", unit);
132: continue;
133: }
134:
135: #ifdef undef
136: IOLog("ATAPI: found ATAPI device %d.\n", unit);
137: #endif undef
138:
139: if ([atapiCnt initResources:direct] == nil) {
140: IOLog("ATAPI: failed to initialize device %d.\n", unit);
141: [atapiCnt free];
142: continue;
143: }
144:
145: /*
146: * To clear pending Unit attention. Not needed.
147: */
148: //[direct atapiRequestSense:NULL];
149:
150: /*
151: * Use this to test before we call registerDevice.
152: */
153: //testDebug(direct);
154:
155: if ([atapiCnt registerDevice] == nil) {
156: IOLog("ATAPI: failed to register device %d.\n", unit);
157: [atapiCnt free];
158: continue;
159: } else {
160: return YES;
161: }
162: }
163: }
164:
165: return NO;
166: }
167:
168: /*
169: * We override IOSCSIController to make ourself look like an indirect device
170: * in order to get connected to IdeController.
171: */
172: + (IODeviceStyle)deviceStyle
173: {
174: return IO_IndirectDevice;
175: }
176:
177: /*
178: * The protocol we need as an indirect device.
179: */
180: static Protocol *protocols[] = {
181: @protocol(AtapiControllerPublic),
182: nil
183: };
184:
185: + (Protocol **)requiredProtocols
186: {
187: return protocols;
188: }
189:
190: - (unsigned short)scsiCmdLen:(IOSCSIRequest *) scsiReq
191: {
192: unsigned char cmdlen;
193: union cdb *cdbp = &scsiReq->cdb;
194:
195: switch (SCSI_OPGROUP(cdbp->cdb_opcode)) {
196:
197: case OPGROUP_0:
198: cmdlen = sizeof(struct cdb_6);
199: break;
200:
201: case OPGROUP_1:
202: case OPGROUP_2:
203: cmdlen = sizeof(struct cdb_10);
204: break;
205:
206: case OPGROUP_5:
207: cmdlen = sizeof(struct cdb_12);
208: break;
209:
210: case OPGROUP_6:
211: if (scsiReq->cdbLength)
212: cmdlen = scsiReq->cdbLength;
213: else
214: cmdlen = sizeof(struct cdb_6);
215: break;
216:
217: case OPGROUP_7:
218: if (scsiReq->cdbLength)
219: cmdlen = scsiReq->cdbLength;
220: else
221: cmdlen = sizeof(struct cdb_10);
222: break;
223:
224: default:
225: scsiReq->driverStatus = SR_IOST_CMDREJ;
226: return 0;
227: }
228:
229: return cmdlen;
230: }
231:
232: #define C10OP_MODESELECT 0x55 /* OPT: set device parameters */
233: #define C10OP_MODESENSE 0x5a /* OPT: get device parameters */
234: #define C10OP_READCAPACITY 0x25 /* read capacity */
235:
236: /*
237: * This will enable us to print last 32 commands in case of an error. The
238: * command that caused the error is printed last.
239: */
240: #ifdef COMMAND_HISTORY
241: #define MAXCMDS 32
242: static atapiIoReq_t cmdBuf[MAXCMDS];
243: static unsigned int cmdPos = 0;
244: static unsigned int cmdsInBuf = 0;
245: #endif COMMAND_HISTORY
246:
247: /*
248: * Do a SCSI command, as specified by an IOSCSIRequest.
249: */
250: - (sc_status_t) executeRequest : (IOSCSIRequest *)scsiReq
251: buffer : (void *)buffer
252: client : (vm_task_t)client
253: {
254: int i;
255: atapiIoReq_t atapiIoReq;
256: atapiBuf_t *atapiBuf;
257: unsigned char *scsiCmd;
258: cdb_t my_cdb;
259: sc_status_t ret;
260: IOReturn driverStatus;
261: BOOL cmdMapped = NO;
262:
263: [_ataController atapiCntrlrLock];
264:
265: my_cdb = scsiReq->cdb;
266:
267: #ifdef DEBUG
268: if ((scsiReq->lun == 0) && (scsiReq->target < 2)) {
269: IOLog("%s: executeRequest %x target %x lun %x Read %d\n",
270: [self name], my_cdb.cdb_opcode, scsiReq->target, scsiReq->lun,
271: scsiReq->read);
272: }
273: #endif DEBUG
274:
275: bzero(&atapiIoReq, sizeof(atapiIoReq_t));
276:
277: atapiIoReq.cmdLen = [_ataController
278: atapiCommandPacketSize:scsiReq->target];
279:
280: atapiIoReq.read = scsiReq->read;
281: atapiIoReq.maxTransfer = scsiReq->maxTransfer;
282: atapiIoReq.drive = scsiReq->target;
283: atapiIoReq.lun = scsiReq->lun;
284: atapiIoReq.timeout = scsiReq->timeoutLength * 1000; // sec to ms
285:
286: // IOLog("max: %d\n", atapiIoReq.maxTransfer);
287:
288: scsiCmd = (unsigned char *) &(my_cdb.cdb_opcode);
289: atapiIoReq.scsiCmd = *scsiCmd;
290:
291: for (i = 0; i < [self scsiCmdLen:scsiReq]; i++) {
292: atapiIoReq.atapiCmd[i] = *scsiCmd;
293: scsiCmd++;
294: }
295:
296: /*
297: * Use this to print SCSI commands being sent to ATA object.
298: */
299:
300: #ifdef COMMAND_PRINT
301: if ((atapiIoReq.atapiCmd[0] == 0x28) && (atapiIoReq.lun == 0)) {
302: IOLog("%s: Command 0x28.\n", [self name]);
303: for (i = 0; i < [self scsiCmdLen:scsiReq]; i+=2) {
304: IOLog("%s: %02x %02x\n", [self name],
305: atapiIoReq.atapiCmd[i], atapiIoReq.atapiCmd[i+1]);
306: }
307:
308: }
309: if ((atapiIoReq.atapiCmd[0] == 0x15) && (atapiIoReq.lun == 0)) {
310: unsigned char *tmp = (unsigned char *)buffer;
311: IOLog("%s: Command 0x15 data.\n", [self name]);
312: for (i = 0; i < 0x1c; i+=2) {
313: IOLog("%s: %02x %02x\n", [self name],
314: tmp[i], tmp[i+1]);
315: }
316: }
317: #endif COMMAND_PRINT
318:
319: #ifdef COMMAND_HISTORY
320: /* Keep history */
321: cmdBuf[cmdPos++] = atapiIoReq;
322: if (cmdsInBuf < MAXCMDS)
323: cmdsInBuf += 1;
324: if (cmdPos == MAXCMDS)
325: cmdPos = 0;
326: #endif COMMAND_HISTORY
327:
328: /*
329: * Map to available ATAPI command if necessary.
330: */
331: for (i = 0; i < sizeof(mapToAtapi)/sizeof(mapToAtapi[0]); i++) {
332: if (atapiIoReq.atapiCmd[0] == mapToAtapi[i]) {
333: //IOLog("%s: Mapping to SCSI command\n", [self name]);
334: bzero((void *)&modeData, sizeof(modeData));
335: if ([self maptoAtapiCmd: &atapiIoReq buffer:buffer
336: newBuffer:&modeData] == NO) {
337: [_ataController atapiCntrlrUnLock];
338: return SR_IOST_CMDREJ;
339: }
340: cmdMapped = YES;
341: break;
342: }
343: }
344:
345: /*
346: * If emulation is successful then return quickly.
347: */
348: if ([self emulateSCSICmd: &atapiIoReq buffer:buffer] == YES) {
349: [_ataController atapiCntrlrUnLock];
350: return SR_IOST_GOOD;
351: }
352:
353: /*
354: * Send the command to the ioThread.
355: */
356: atapiBuf = [self allocAtapiBuf];
357: atapiBuf->atapiIoReq = &atapiIoReq;
358: if (cmdMapped) {
359: atapiBuf->buffer = (void *)&modeData;
360: atapiBuf->client = IOVmTaskSelf();
361: }
362: else {
363: atapiBuf->buffer = buffer;
364: atapiBuf->client = client;
365: }
366: atapiBuf->command = ATAPI_CNT_IOREQ;
367: driverStatus = [self enqueueAtapiBuf:atapiBuf];
368: ret = atapiBuf->status; // SCSI status
369:
370: /*
371: * Re-map to SCSI command if necessary.
372: */
373: if (driverStatus == SR_IOST_GOOD) {
374: for (i = 0; i < sizeof(mapToAtapi)/sizeof(mapToAtapi[0]); i++) {
375: if (atapiIoReq.scsiCmd == mapToAtapi[i]) {
376: if ([self maptoSCSICmd: &atapiIoReq buffer:buffer
377: newBuffer:&modeData] == NO) {
378: [_ataController atapiCntrlrUnLock];
379: return SR_IOST_CMDREJ;
380: }
381: break;
382: }
383: }
384: }
385:
386: [self freeAtapiBuf:atapiBuf];
387:
388: /*
389: * Use this to filter and print data returned from the device.
390: */
391: #ifdef DEBUG
392: {
393: unsigned char *buf = (unsigned char *)buffer;
394: if ((atapiIoReq.atapiCmd[0] == 0x25) && (atapiIoReq.lun == 0)) {
395: IOLog("%s: Returned data.\n", [self name]);
396: for (i = 0; i < atapiIoReq.bytesTransferred; i+=4) {
397: IOLog("%s: %02x %02x %02x %02x\n", [self name], buf[i],
398: buf[i+1], buf[i+2], buf[i+3]);
399: }
400: IOLog("%s: total bytes transferred = %d\n", [self name],
401: atapiIoReq.bytesTransferred);
402: IOLog("%s: scsi status: %x driver status: %x\n", [self name],
403: atapiIoReq.scsiStatus, ret);
404: }
405:
406: }
407: #endif DEBUG
408:
409: /*
410: * This is a workaround for the Mitsumi Read CD-ROM capacity bug. It
411: * reports the block size as 2352 bytes instead of 2048 bytes. It is
412: * including preamble and other info. I have seen this on MITSUMI CD-ROM
413: * !B B02. The workaround is truncate the returned value. Remove this
414: * when it is no longer needed.
415: */
416: {
417: unsigned int blockSize, value;
418: char *buf = (char *)buffer;
419: if ((atapiIoReq.atapiCmd[0] == C10OP_READCAPACITY) &&
420: (atapiIoReq.lun == 0)) {
421: blockSize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) |
422: buf[7];
423: if (blockSize == 0) /* self defense */
424: blockSize = 2048;
425: for (value = 16; value < blockSize; value *= 2)
426: ;
427: if (value > blockSize) {
428: //IOLog("%s: block size set to %d from %d\n", [self name], value/2, blockSize);
429: blockSize = value / 2;
430: buf[4] = (blockSize >> 24) & 0xff;
431: buf[5] = (blockSize >> 16) & 0xff;
432: buf[6] = (blockSize >> 8) & 0xff;
433: buf[7] = blockSize & 0xff;
434: }
435: }
436: }
437:
438: #ifdef COMMAND_HISTORY
439: {
440: int j, k;
441:
442: /* Print history in case of error. */
443: if ((ret != SR_IOST_GOOD) && (atapiIoReq.atapiCmd[0] != 0x00)
444: && (atapiIoReq.atapiCmd[0] != 0x12)) {
445: IOLog("%s: Command %02x failed. Backtrace..\n", [self name],
446: atapiIoReq.atapiCmd[0]);
447: i = (cmdPos - cmdsInBuf) % MAXCMDS;
448: k = (int) cmdsInBuf;
449: while (--k >= 0) {
450: IOLog("%s: ", [self name]);
451: for (j = 0; j < 12; j++) {
452: IOLog("%02x ", cmdBuf[i].atapiCmd[j]);
453: }
454: IOLog("\n");
455: if (i == MAXCMDS)
456: i = 0;
457: else
458: i += 1;
459: }
460: cmdsInBuf = 0;
461: }
462: }
463: #endif COMMAND_HISTORY
464:
465: scsiReq->bytesTransferred = atapiIoReq.bytesTransferred;
466: scsiReq->scsiStatus = atapiIoReq.scsiStatus;
467: scsiReq->driverStatus = driverStatus;
468:
469: [_ataController atapiCntrlrUnLock];
470:
471: return ret;
472: }
473:
474: #define MPH_SCSI_6_SIZE sizeof(mode_sel_hdr_t)
475: #define MPH_SCSI_10_SIZE 8
476: #define MPH_ATAPI_SIZE sizeof(atapiMPH_t)
477: #define MPH_DELTA (MPH_ATAPI_SIZE - MPH_SCSI_6_SIZE)
478:
479: /*
480: * Map SCSI commands into ATAPI commands.
481: * We use this to modify the SCSI Mode Sense/Select commands to fit
482: * the ATAPI protocol.
483: *
484: * FIXME - We do not handle multiple mode pages. Only the first page is
485: * translated.
486: */
487: - (BOOL) maptoAtapiCmd:(atapiIoReq_t *)atapiIoReq
488: buffer:(void *)buffer
489: newBuffer:(atapiMPL_t *)mode
490: {
491: int i, pageLength, bd_len, page_start, hdr_size, maxTransfer;
492: unsigned char *data = (unsigned char *)buffer;
493:
494: /*
495: * Modify the SCSI mode sense (6) command.
496: *
497: * SCSI mode sense (10) should be fine for ATAPI since it matches
498: * the ATAPI spec very closely.
499: */
500: if (atapiIoReq->scsiCmd == C6OP_MODESENSE) {
501:
502: /*
503: * Our ATAPI buffer must be MPH_DELTA bytes larger than the size
504: * of the SCSI buffer passed in.
505: */
506: if ((atapiIoReq->atapiCmd[4] + MPH_DELTA) > sizeof(atapiMPL_t))
507: return NO;
508:
509: /*
510: * Transform the SCSI mode sense (6) command into a SCSI
511: * mode sense (10) command.
512: */
513: atapiIoReq->atapiCmd[0] = C10OP_MODESENSE;
514: atapiIoReq->atapiCmd[8] = atapiIoReq->atapiCmd[4] + MPH_DELTA;
515: atapiIoReq->atapiCmd[4] = 0;
516: atapiIoReq->atapiCmd[5] = 0;
517:
518: /* Increase the maxTransfer by 4 bytes, since in SCSI Mode
519: * Sense(6), the Mode Parameter Header is only 4 bytes long,
520: * while in ATAPI, it is always 8-bytes. Therefore, we may
521: * need to transfer 4 additional bytes over the set SCSI limit.
522: * We also know that we have enough storage since we did the
523: * check earlier.
524: */
525: atapiIoReq->maxTransfer += MPH_DELTA;
526:
527: return YES;
528: }
529:
530: /*
531: * Modify the SCSI mode select commands.
532: */
533: if ((atapiIoReq->scsiCmd == C6OP_MODESELECT) ||
534: (atapiIoReq->scsiCmd == C10OP_MODESELECT)) {
535:
536: if (atapiIoReq->scsiCmd == C6OP_MODESELECT) {
537: atapiIoReq->atapiCmd[0] = C10OP_MODESELECT;
538: atapiIoReq->atapiCmd[4] = 0;
539: atapiIoReq->atapiCmd[5] = 0; /* reset control field */
540:
541: bd_len = data[3]; /* block descriptor length */
542: hdr_size = MPH_SCSI_6_SIZE; /* mode parameter hdr size */
543: }
544: else { // C10OP_MODESELECT
545: atapiIoReq->atapiCmd[9] = 0; /* reset control field */
546: bd_len = (data[6] << 8) | data[7]; /* block descriptor length */
547: hdr_size = MPH_SCSI_10_SIZE; /* mode parameter hdr size */
548: }
549:
550: page_start = hdr_size + bd_len; /* start of mode page */
551: pageLength = data[page_start + 1] + 2; /* total size of mode page */
552: if (pageLength > MODSEL_DATA_LEN) /* page too large */
553: return NO;
554:
555: /* copy the mode page to our own buffer space */
556: for (i = 0; i < pageLength; i++) {
557: mode->pageData[i] = data[page_start + i];
558: }
559:
560: /* Update allocation length in the mode select command.
561: * length = page size + ATAPI header size
562: */
563: maxTransfer = pageLength + MPH_ATAPI_SIZE;
564: atapiIoReq->atapiCmd[8] = maxTransfer & 0xff; /* LSB */
565: atapiIoReq->atapiCmd[7] = (maxTransfer >> 8) & 0xff; /* MSB */
566:
567: /*
568: * Update the maxTransfer count.
569: */
570: atapiIoReq->maxTransfer = maxTransfer;
571: return YES;
572: }
573:
574: return YES;
575: }
576:
577: /*
578: * Map the result of ATAPI commands into their SCSI counterparts.
579: *
580: * FIXME - We do not handle multiple mode pages. Only the first page is
581: * translated.
582: */
583: - (BOOL) maptoSCSICmd:(atapiIoReq_t *)atapiIoReq
584: buffer:(void *)buffer
585: newBuffer:(atapiMPL_t *)mode
586: {
587: int i, pageLength;
588: unsigned char *data = (unsigned char *)buffer;
589:
590: /*
591: * If the executed command was originally a SCSI Mode Sense(6)
592: * command, we need to modify the result since the returned
593: * Page Parameter Header size is now 8-bytes instead of the
594: * expected 4-bytes.
595: */
596: if ((atapiIoReq->scsiCmd == C6OP_MODESENSE) &&
597: (atapiIoReq->bytesTransferred >= 10)) {
598:
599: // bytesTransferred must be greater than 10 or otherwise the
600: // PageLength field in the page (byte 1) would not be valid.
601:
602: pageLength = mode->pageData[1] + 2;
603:
604: /* Mode Page + Mode Header must fit in the SCSI buffer.
605: * Remember that the value in atapiCmd[8] was
606: * artificially increased by 4 bytes, so we need to
607: * take that into account.
608: */
609: if ((pageLength + MPH_SCSI_6_SIZE) >
610: (atapiIoReq->atapiCmd[8] - MPH_DELTA)) {
611: /* SCSI buffer is too small */
612: #ifdef DEBUG
613: IOLog("maptoSCSICmd: Mode Select buffer too small\n");
614: #endif DEBUG
615: return NO;
616: }
617:
618: data[0] = mode->mph.mdl0; // mode data length
619: data[1] = mode->mph.mt; // medium type
620: data[2] = 0; // device-specific parameter
621: data[3] = 0; // block descriptor length
622:
623: for (i = 0; i < pageLength; i++) {
624: data[4 + i] = mode->pageData[i];
625: }
626:
627: /*
628: * Modify bytesTransferred count to make it appear that
629: * we transferred 4 less bytes.
630: */
631: atapiIoReq->bytesTransferred -= MPH_DELTA;
632: return YES;
633: }
634:
635: return YES;
636: }
637:
638: /*
639: * If this SCSI command is not supported by ATAPI then try to fake its
640: * execution if possible.
641: */
642: - (BOOL) emulateSCSICmd:(atapiIoReq_t *)atapiIoReq buffer:(void *)buffer
643: {
644: unsigned char *data = (unsigned char *)buffer;
645:
646: /*
647: * We need to fake mode sense page 2. Workspace sends that and this page
648: * is reserved in ATAPI. In the SCSI world this page is for
649: * disconnect-reconnect and ATAPI doesn't support that now.
650: */
651: if (atapiIoReq->atapiCmd[0] == C10OP_MODESENSE) {
652: if ((atapiIoReq->atapiCmd[2] & 0x1f) == 0x02) {
653: bzero(data, atapiIoReq->atapiCmd[4]);
654: data[0] = 0x02;
655: data[1] = atapiIoReq->atapiCmd[4];
656: data[2] = 1; /* our preferred size: 2048 bytes */
657: atapiIoReq->bytesTransferred = atapiIoReq->atapiCmd[4];
658: atapiIoReq->scsiStatus = STAT_GOOD;
659:
660: return YES;
661: }
662: }
663:
664: return NO; /* default */
665: }
666:
667:
668: /*
669: * Reset all ATAPI devices connected to this controller. Note that we have
670: * obtain a lock before resetting the controller.
671: */
672: - (sc_status_t)resetSCSIBus
673: {
674: int unit;
675: atapi_return_t ret;
676: sc_status_t status = SR_IOST_GOOD;
677:
678: for (unit = 0; unit < [_ataController numDevices]; unit++) {
679:
680: if ([_ataController isAtapiDevice:unit]) {
681:
682: [_ataController atapiCntrlrLock];
683: ret = [_ataController atapiSoftReset:unit];
684: [_ataController atapiCntrlrUnLock];
685:
686: if (ret != IDER_SUCCESS) {
687: IOLog("%s: ATAPI reset failed.\n", [self name]);
688: status = SR_IOST_HW;
689: }
690: }
691: }
692:
693: return status;
694: }
695:
696: #ifdef undef
697: /* For testing individual commands. */
698: static void testDebug(id driver)
699: {
700: void *buffer;
701: atapiIoReq_t atapiIoReq;
702:
703: buffer = IOMalloc(2048);
704: bzero(&atapiIoReq, sizeof(atapiIoReq_t));
705:
706: atapiIoReq.cmdLen = 12;
707: atapiIoReq.read = 1;
708: atapiIoReq.drive = 0;
709: atapiIoReq.lun = 0;
710:
711: atapiIoReq.atapiCmd[0] = 0x28;
712: atapiIoReq.atapiCmd[2] = 0;
713: atapiIoReq.atapiCmd[3] = 0;
714: atapiIoReq.atapiCmd[4] = 0;
715: atapiIoReq.atapiCmd[5] = 5;
716: atapiIoReq.atapiCmd[7] = 0;
717: atapiIoReq.atapiCmd[8] = 1;
718:
719: [driver atapiExecuteCmd:&atapiIoReq
720: buffer:buffer client:IOVmTaskSelf()];
721:
722: }
723: #endif undef
724:
725: - property_IODeviceClass:(char *)classes length:(unsigned int *)maxLen
726: {
727: strcpy( classes, IOClassATAPIController);
728: return( self);
729: }
730:
731: - property_IODeviceType:(char *)types length:(unsigned int *)maxLen
732: {
733: strcat( types, " "IOTypeATAPI);
734: return( self);
735: }
736:
737: @end
738:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.