![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Apple96SCSI.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvApple96_SCSI|
Return to Apple96SCSI.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvApple96_SCSI |
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.1 (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: /**
26: * Copyright (c) 1994-1996 NeXT Software, Inc. All rights reserved.
27: * Copyright 1997 Apple Computer Inc. All Rights Reserved.
28: * @author Martin Minow mailto:[email protected]
29: * @revision 1997.02.18 Initial conversion from AMDPCSCSIDriver sources.
30: *
31: * Apple96SCSI.h - "Main" public methods for the 53C96 PCI SCSI interface.
32: * Apple96SCSI is closely based on Doug Mitchell's AMD 53C974/79C974 driver.
33: *
34: * Hmm, these methods are probably common to all SCSI implementations.
35: *
36: * Edit History
37: * 1998.07.29 MM Disable logRegisters on command timeout.
38: * 1997.02.13 MM Initial conversion from AMDPCSCSIDriver sources.
39: * 1997.11.12 MM Added support for scatter-gather lists.
40: */
41: #import "Apple96SCSI.h"
42: #import "Apple96SCSIPrivate.h"
43: #import "Apple96CurioPrivate.h"
44: #import "Apple96CurioPublic.h"
45: #import "Apple96CurioDBDMA.h"
46: #import "Apple96Hardware.h"
47: #import "Apple96HWPrivate.h"
48: #import "Apple96ISR.h"
49: #import "bringup.h"
50: #import <mach/message.h>
51: #import <driverkit/generalFuncs.h>
52: #import <driverkit/interruptMsg.h>
53: #import <driverkit/align.h>
54: #import <driverkit/kernelDriver.h>
55: #import <kernserv/prototypes.h>
56: #import <driverkit/IOSimpleMemoryDescriptor.h>
57: /* string.h defines bzero */
58: #import <string.h>
59:
60:
61: @implementation Apple96_SCSI
62:
63: /*
64: * Create and initialize one instance of Apple96_SCSI. The work is done by
65: * architecture- and chip-specific modules.
66: */
67: + (Boolean) probe : deviceDescription
68: {
69: Apple96_SCSI *inst = [self alloc];
70: Boolean result;
71:
72: ENTRY("Spr probe");
73: MakeTimestampRecord(512); /* TBS: contitionally compile */
74: /*
75: * Perform device-specific initialization -- free the instance
76: * on failure.
77: */
78: if ([inst hardwareInitialization : deviceDescription] == nil) {
79: result = NO;
80: }
81: else {
82: result = YES;
83: }
84: RESULT(result);
85: return (result);
86: }
87:
88: - free
89: {
90: CommandBuffer cmdBuf;
91:
92: ENTRY("Sfr free");
93: /*
94: * First kill the I/O thread if running.
95: */
96: if (gFlagIOThreadRunning) {
97: cmdBuf.op = kCommandAbortRequest;
98: cmdBuf.scsiReq = NULL;
99: [self executeCmdBuf:&cmdBuf];
100: }
101: if (gIncomingCommandLock != NULL) {
102: [gIncomingCommandLock free];
103: }
104: [self dbdmaTerminate]; /* Free up DBDMA memory */
105: EXIT();
106: return [super free];
107: }
108:
109:
110: /*
111: * Return required DMA alignment for current architecture.
112: */
113: - (void)getDMAAlignment : (IODMAAlignment *)alignment;
114: {
115: alignment->readStart = DBDMA_ReadStartAlignment;
116: alignment->writeStart = DBDMA_WriteStartAlignment;
117: alignment->readLength = DBDMA_ReadLengthAlignment;
118: alignment->writeLength = DBDMA_WriteLengthAlignment;
119: }
120:
121: /*
122: * Statistics support.
123: */
124: - (unsigned int) numQueueSamples
125: {
126: return (gTotalCommands);
127: }
128:
129:
130: - (unsigned int) sumQueueLengths
131: {
132: return (gQueueLenTotal);
133: }
134:
135:
136: - (unsigned int) maxQueueLength
137: {
138: return (gMaxQueueLen);
139: }
140:
141:
142: - (void)resetStats
143: {
144: gTotalCommands = 0;
145: gQueueLenTotal = 0;
146: gMaxQueueLen = 0;
147: }
148:
149: /**
150: * Do a SCSI command, as specified by an IOSCSIRequest. All the
151: * work is done by the I/O thread.
152: * @param scsiReq The request to execute
153: * @param buffer The data buffer to transfer to/from, if any
154: * @param client The data buffer owner task (for VM munging)
155: *
156: * This method is called from IOSCSIDevice
157: */
158: - (sc_status_t) executeRequest
159: : (IOSCSIRequest *) scsiReq
160: buffer : (void *) buffer
161: client : (vm_task_t) client
162: {
163: IOMemoryDescriptor *mem = NULL;
164: sc_status_t scsiStatus = SR_IOST_GOOD; /* Fool compiler */
165:
166: ENTRY("Ser executeRequest");
167: /*
168: * Create a simple I/O memory descriptor for this client,
169: * then toss it to the common method.
170: */
171: if (buffer != NULL) {
172: mem = [[IOSimpleMemoryDescriptor alloc]
173: initWithAddress : (void *) buffer
174: length : scsiReq->maxTransfer
175: ];
176: [mem setClient : client];
177: }
178: scsiStatus = [self executeRequest
179: : scsiReq
180: ioMemoryDescriptor : mem
181: ];
182: if (mem != NULL) {
183: [mem release];
184: }
185: RESULT(scsiReq->bytesTransferred);
186: return (scsiStatus);
187: }
188:
189: /*
190: * Execute a SCSI request using an IOMemoryDescriptor. This allows callers to
191: * provide (kernel-resident) logical scatter-gather lists. For compatibility
192: * with existing implementations, the low-level SCSI device driver must first
193: * ensure that executeRequest:ioMemoryDescriptor is supported by executing:
194: * [controller respondsToSelector : executeRequest:ioMemoryDescriptor]
195: */
196: - (sc_status_t) executeRequest
197: : (IOSCSIRequest *) scsiReq
198: ioMemoryDescriptor : (IOMemoryDescriptor *) ioMemoryDescriptor
199: {
200: CommandBuffer commandBuffer;
201:
202: ENTRY("Sem executeRequest (IOMemoryDescriptor)");
203: TAG("Ser", scsiReq->maxTransfer);
204: ddmExported("executeRequest: cmdBuf 0x%x maxTransfer 0x%x\n",
205: &commandBuffer,
206: scsiReq->maxTransfer,
207: 3,4,5
208: );
209: if (ioMemoryDescriptor != NULL) {
210: [ioMemoryDescriptor setMaxSegmentCount : kMaxDMATransfer];
211: [ioMemoryDescriptor state : &commandBuffer.savedDataState];
212: }
213: bzero(&commandBuffer, sizeof(CommandBuffer));
214: commandBuffer.op = kCommandExecute;
215: commandBuffer.scsiReq = scsiReq;
216: commandBuffer.mem = ioMemoryDescriptor;
217: scsiReq->driverStatus = SR_IOST_INVALID; /* "In progress" */
218: [self executeCmdBuf : &commandBuffer];
219: ddmExported("executeRequest: cmdBuf 0x%x complete; driverStatus %s\n",
220: &commandBuffer,
221: IOFindNameForValue(scsiReq->driverStatus, IOScStatusStrings),
222: 3,4,5
223: );
224: RESULT(commandBuffer.scsiReq->bytesTransferred);
225: #if TIMESTAMP_AT_IOCOMPLETE
226: [self logTimestamp : "I/O complete"]; /* After RETURN macro */
227: #endif
228: return (commandBuffer.scsiReq->driverStatus);
229: }
230:
231: /**
232: * Reset the SCSI bus. All the work is done by the I/O thread.
233: */
234: - (sc_status_t) resetSCSIBus
235: {
236: CommandBuffer commandBuffer;
237:
238: ENTRY("Sre resetSCSIBus");
239: ddmExported("resetSCSIBus: cmdBuf 0x%x\n",
240: &commandBuffer,
241: 2, 3,4,5
242: );
243:
244: commandBuffer.op = kCommandResetBus;
245: commandBuffer.scsiReq = NULL;
246:
247: [self executeCmdBuf:&commandBuffer];
248: ddmExported("resetSCSIBus: cmdBuf 0x%x DONE\n",
249: &commandBuffer,
250: 2, 3,4,5
251: );
252: RESULT(SR_IOST_GOOD);
253: return (SR_IOST_GOOD); /* can not fail */
254: }
255:
256: /*
257: * The following 6 methods are all called from the I/O thread in IODirectDevice.
258: */
259:
260: /*
261: * Called from the I/O thread when it receives an interrupt message.
262: * Currently all work is done by chip-specific module; maybe we should
263: * put this method there....
264: */
265: - (void) interruptOccurred
266: {
267: ENTRY("Sin interruptOccurred");
268: /*
269: * Note: the following compiles because ENTRY ends with "do {"
270: */
271: #if DDM_DEBUG
272: {
273: /*
274: * calculate interrupt service time if enabled.
275: */
276: ns_time_t startTime;
277: unsigned elapsedNSec = 0;
278:
279: if (IODDMMasks[APPLE96_DDM_INDEX] & DDM_INTR) {
280: IOGetTimestamp(&startTime);
281: }
282: ddmInterrupt("interruptOccurred: TOP\n", 1,2,3,4,5);
283: #endif DDM_DEBUG
284: [self hardwareInterrupt];
285: #if DDM_DEBUG
286: if (IODDMMasks[APPLE96_DDM_INDEX] & DDM_INTR) {
287: ns_time_t endTime;
288:
289: IOGetTimestamp(&endTime);
290: elapsedNSec = (unsigned) (endTime - startTime);
291: }
292: ddmInterrupt("interruptOccurred: DONE; elapsed time %d.%03d us\n",
293: elapsedNSec / 1000U,
294: elapsedNSec - ((elapsedNSec / 1000U) * 1000U),
295: 3,4,5
296: );
297: }
298: #endif DDM_DEBUG
299: // [self enableInterrupt:0];
300: // [self enableAllInterrupts ];
301: EXIT();
302: }
303:
304: /*
305: * These three should not occur; they are here as error traps. All three are
306: * called out from the I/O thread upon receipt of messages which it should
307: * not be seeing.
308: */
309: - (void)interruptOccurredAt:(int)localNum
310: {
311: IOLog("%s: interruptOccurredAt:%d\n", [self name], localNum);
312: }
313:
314: - (void)otherOccurred:(int)id
315: {
316: IOLog("%s: otherOccurred:%d\n", [self name], id);
317: }
318:
319: - (void)receiveMsg
320: {
321: IOLog("%s: receiveMsg\n", [self name]);
322:
323: /*
324: * We have to let IODirectDevice take care of this (i.e., dequeue the
325: * bogus message).
326: */
327: [super receiveMsg];
328: }
329:
330: /*
331: * Used in -timeoutOccurred to determine if specified cmdBuf has timed out.
332: * Returns YES if timeout, else NO.
333: */
334: static inline Boolean
335: isCmdTimedOut(
336: CommandBuffer *cmdBuf,
337: ns_time_t now
338: )
339: {
340: IOSCSIRequest *scsiReq;
341: ns_time_t expire;
342: Boolean result;
343:
344: ENTRY("Sit isCmdTimedOut");
345: scsiReq = cmdBuf->scsiReq;
346: expire = cmdBuf->startTime +
347: (1000000000ULL * (unsigned long long) scsiReq->timeoutLength);
348: result = (now > expire);
349: #if 0
350: if (result) {
351: IOLog("%s: command timeout, target %d exceeded %d\n"
352: "drvApple96SCSI", /* Can't use [self name] here */
353: (int) scsiReq->target,
354: (int) scsiReq->timeoutLength
355: );
356: }
357: #endif
358: RESULT(result);
359: return (result);
360: }
361:
362: /*
363: * Called from the I/O thread when it receives a timeout
364: * message. We send these messages ourself from serviceTimeoutInterrupt().
365: */
366: - (void) timeoutOccurred
367: {
368: ns_time_t now;
369: Boolean cmdTimedOut = NO;
370: CommandBuffer *cmdBuf = gActiveCommand;
371: CommandBuffer *nextCmdBuf;
372:
373: ENTRY("Sto timeoutOccurred");
374: ddmThread("timeoutOccurred: TOP\n", 1,2,3,4,5);
375: IOGetTimestamp(&now);
376: #if 0 /* Disable. Part of Radar 2261237 */
377: [self logRegisters : TRUE reason : "TimeoutOccurred"];
378: #endif /* Disable. Part of Radar 2261237 */
379: // ** ** **
380: // ** ** ** Umm, is there a race-condition here? Can gActiveCommand be changed
381: // ** ** ** out from under us by an interrupt or does the O.S. ensure that
382: // ** ** ** these methods are single-threaded? Also, note that the bus
383: // ** ** ** is likely to be stuck if there is a very slow device
384: // ** ** ** such as a Format or Tape Rewind ongoing. This needs to be
385: // ** ** ** updated to use the Copland (and/or SCSI Manager 4.3) algorithms.
386: // ** ** **
387: /*
388: * Scan gActiveCommand and disconnectQ looking for tardy I/Os.
389: */
390: if (cmdBuf != NULL) {
391: if (isCmdTimedOut(cmdBuf, now)) {
392: ddmThread("gActiveCommand TIMEOUT, cmd 0x%x\n",
393: cmdBuf, 2,3,4,5);
394: gActiveCommand = NULL;
395: /*
396: * ** ** ** Umm, what about abort commands?
397: */
398: ASSERT(cmdBuf->scsiReq != NULL);
399: [self ioComplete
400: : cmdBuf
401: finalStatus : SR_IOST_IOTO
402: ];
403: cmdTimedOut = YES;
404: }
405: }
406: /*
407: * ** ** **
408: * ** ** ** Umm, disconnected commands should timeout only
409: * ** ** ** when the bus is idle. Otherwise, we can timeout
410: * ** ** ** a command whose only fault is that other commands
411: * ** ** ** saturated the bus.
412: */
413: cmdBuf = (CommandBuffer *) queue_first(&gDisconnectedCommandQueue);
414: while (queue_end(&gDisconnectedCommandQueue, (queue_entry_t) cmdBuf) == 0) {
415: if (isCmdTimedOut(cmdBuf, now)) {
416: ddmThread("disconnected cmd timeout, cmd 0x%x\n", cmdBuf, 2,3,4,5);
417:
418: /*
419: * Remove cmdBuf from disconnectQ and complete it.
420: */
421: nextCmdBuf = (CommandBuffer *) queue_next(&cmdBuf->link);
422: queue_remove(&gDisconnectedCommandQueue, cmdBuf, CommandBuffer *, link);
423: ASSERT(cmdBuf->scsiReq != NULL);
424: [self ioComplete
425: : cmdBuf
426: finalStatus : SR_IOST_IOTO
427: ];
428: cmdBuf = nextCmdBuf;
429: cmdTimedOut = YES;
430: }
431: else {
432: cmdBuf = (CommandBuffer *) queue_next(&cmdBuf->link);
433: }
434: }
435: /*
436: * ** ** **
437: * ** ** ** This is a really big hammer -- and will cause problems
438: * ** ** ** with tape drives. It may also cause data loss.
439: * ** ** **
440: * Reset bus. This also completes all I/Os in disconnectQ with
441: * status CS_Reset.
442: */
443: if (cmdTimedOut) {
444: [self logRegisters : TRUE reason : "Command timeout"];
445: [self threadResetBus:NULL];
446: }
447: ddmThread("timeoutOccurred: DONE\n", 1,2,3,4,5);
448: EXIT();
449: }
450:
451: /*
452: * Process all commands in gIncomingCommandQueue. At most one of these will become
453: * gActiveCommand. The remainder of kCommandExecute commands go to gPendingCommandQueue. Other
454: * types of commands (such as bus reset) are executed immediately.
455: *
456: * This method is called from IODirectDevice.
457: * ** ** **
458: * ** ** ** Note that we don't have a concept of frozen queue.
459: * ** ** **
460: */
461: - (void) commandRequestOccurred
462: {
463: CommandBuffer *cmdBuf;
464: CommandBuffer *pendCmd;
465:
466: ENTRY("Sco commandRequestOccurred");
467: ddmThread("commandRequestOccurred: top\n", 1,2,3,4,5);
468: [gIncomingCommandLock lock];
469: while (queue_empty(&gIncomingCommandQueue) == FALSE) {
470: cmdBuf = (CommandBuffer *) queue_first(&gIncomingCommandQueue);
471: queue_remove(&gIncomingCommandQueue, cmdBuf, CommandBuffer *, link);
472: [gIncomingCommandLock unlock];
473: switch (cmdBuf->op) {
474: case kCommandResetBus:
475: /*
476: * Note all active and disconnected commands will
477: * be terminted.
478: */
479: [self threadResetBus : "Reset Command Received"];
480: [self ioComplete
481: : cmdBuf
482: finalStatus : SR_IOST_RESET
483: ];
484: break;
485: case kCommandAbortRequest:
486: /*
487: * 1. Abort all active, pending, and disconnected
488: * commands.
489: * 2. Notify caller of completion.
490: * 3. Self-terminate.
491: */
492: [self abortAllCommands : SR_IOST_INT];
493: pendCmd = (CommandBuffer *) queue_first(&gPendingCommandQueue);
494: while (queue_end(&gPendingCommandQueue, (queue_entry_t) pendCmd) == FALSE) {
495: [self ioComplete
496: : pendCmd
497: finalStatus : SR_IOST_INT
498: ];
499: pendCmd = (CommandBuffer *) queue_next(&pendCmd->link);
500: }
501: [cmdBuf->cmdLock lock];
502: [cmdBuf->cmdLock unlockWith:CMD_COMPLETE];
503: ddmEntry("-Method: commandRequestOccurred", 1, 2, 3, 4, 5);
504: IOExitThread();
505: /* not reached */
506: case kCommandExecute:
507: [self threadExecuteRequest:cmdBuf];
508: break;
509:
510: }
511: [gIncomingCommandLock lock];
512: }
513: [gIncomingCommandLock unlock];
514: ddmThread("commandRequestOccurred: DONE\n", 1,2,3,4,5);
515: EXIT();
516: }
517:
518:
519: /*
520: * Power management methods. All we care about is power off, when we must
521: * reset the SCSI bus due to the Compaq BIOS's lack of a SCSI reset, which
522: * causes a hang if we have set up targets for sync data transfer mode.
523: */
524: - (IOReturn) getPowerState : (PMPowerState *) state_p
525: {
526: ddmExported("getPowerState called\n", 1,2,3,4,5);
527: return IO_R_UNSUPPORTED;
528: }
529:
530: - (IOReturn) setPowerState : (PMPowerState) state
531: {
532: #ifdef DEBUG
533: IOLog("%s: received setPowerState: with %x\n", [self name],
534: (unsigned)state);
535: #endif DEBUG
536: if (state == PM_OFF) {
537: // [self scsiReset];
538: // ** ** ** TBS: [self powerDown];
539: return IO_R_SUCCESS;
540: }
541: return IO_R_UNSUPPORTED;
542: }
543:
544: - (IOReturn) getPowerManagement : (PMPowerManagementState *) state_p
545: {
546: ddmExported("getPowerManagement called\n", 1,2,3,4,5);
547: return IO_R_UNSUPPORTED;
548: }
549:
550: - (IOReturn) setPowerManagement : (PMPowerManagementState) state
551: {
552: ddmExported("setPowerManagement called\n", 1,2,3,4,5);
553: return IO_R_UNSUPPORTED;
554: }
555:
556: #if APPLE96_ENABLE_GET_SET
557:
558: /**
559: * Called by clients (and user-interaction) to configure the device.
560: */
561: - (IOReturn) setIntValues
562: : (unsigned *) parameterArray
563: forParameter : (IOParameterName) parameterName
564: count : (unsigned int) count
565: {
566: IOReturn ioReturn = IO_R_INVALID_ARG;
567:
568: /* Radar 1670762 ENTRY("Ssi setIntValues"); */
569: ddmExported("setIntValues %s, count %u\n",
570: parameterName,
571: count,
572: 3, 4, 5
573: );
574: if (strcmp(parameterName, APPLE96_AUTOSENSE) == 0) {
575: if (count == 1) {
576: gOptionAutoSenseEnable = (parameterArray[0] ? 1 : 0);
577: IOLog("%s: autoSense %s\n", [self name],
578: (gOptionAutoSenseEnable ? "Enabled" : "Disabled"));
579: ioReturn = IO_R_SUCCESS;
580: }
581: }
582: else if (strcmp(parameterName, APPLE96_ENABLE_DISCONNECT) == 0) { /* Radar 2005639 */
583: if (count == 1) {
584: gOptionDisconnectEnable = (parameterArray[0] ? 1 : 0);
585: IOLog("%s: disconnect %s\n", [self name],
586: (gOptionDisconnectEnable ? "Enabled" : "Disabled"));
587: ioReturn = IO_R_SUCCESS;
588: }
589: }
590: else if (strcmp(parameterName, APPLE96_CMD_QUEUE) == 0) {
591: if (count == 1) {
592: gOptionCmdQueueEnable = (parameterArray[0] ? 1 : 0);
593: IOLog("%s: cmdQueue %s\n", [self name],
594: (gOptionCmdQueueEnable ? "Enabled" : "Disabled"));
595: ioReturn = IO_R_SUCCESS;
596: }
597: }
598: else if (strcmp(parameterName, APPLE96_SYNC) == 0) {
599: if (count == 1) {
600: gOptionSyncModeEnable = (parameterArray[0] ? 1 : 0);
601: IOLog("%s: syncMode %s\n", [self name],
602: (gOptionSyncModeEnable ? "Enabled" : "Disabled"));
603: ioReturn = IO_R_SUCCESS;
604: }
605: }
606: else if (strcmp(parameterName, APPLE96_FAST_SCSI) == 0) {
607: if (count == 1) {
608: gOptionFastModeEnable = (parameterArray[0] ? 1 : 0);
609: IOLog("%s: fastMode %s\n", [self name],
610: (gOptionFastModeEnable ? "Enabled" : "Disabled"));
611: ioReturn = IO_R_SUCCESS;
612: }
613: }
614: else if (strcmp(parameterName, APPLE96_RESET_TARGETS) == 0) {
615: if (count == 0) {
616: int target;
617:
618: /*
619: * Re-enable sync and command queueing. The
620: * disable bits persist after a reset.
621: */
622: for (target = 0; target < SCSI_NTARGETS; target++) {
623: PerTargetData *perTargetPtr;
624:
625: perTargetPtr = &gPerTargetData[target];
626: perTargetPtr->cmdQueueDisable = FALSE;
627: perTargetPtr->selectATNDisable = FALSE;
628: perTargetPtr->maxQueue = 0;
629: }
630: IOLog("%s: Per Target disable flags cleared\n", [self name]);
631: ioReturn = IO_R_SUCCESS;
632: }
633: }
634: else if (strcmp(parameterName, APPLE96_RESET_TIMESTAMP) == 0) {
635: ResetTimestampIndex();
636: ioReturn = IO_R_SUCCESS;
637: }
638: else if (strcmp(parameterName, APPLE96_ENABLE_TIMESTAMP) == 0) {
639: EnableTimestamp(TRUE);
640: ioReturn = IO_R_SUCCESS;
641: }
642: else if (strcmp(parameterName, APPLE96_DISABLE_TIMESTAMP) == 0) {
643: EnableTimestamp(FALSE);
644: ioReturn = IO_R_SUCCESS;
645: }
646: else if (strcmp(parameterName, APPLE96_PRESERVE_FIRST_TIMESTAMP) == 0) {
647: PreserveTimestamp(TRUE);
648: ioReturn = IO_R_SUCCESS;
649: }
650: else if (strcmp(parameterName, APPLE96_PRESERVE_LAST_TIMESTAMP) == 0) {
651: PreserveTimestamp(FALSE);
652: ioReturn = IO_R_SUCCESS;
653: }
654: else {
655: ioReturn = [super setIntValues
656: : parameterArray
657: forParameter : parameterName
658: count : count
659: ];
660: }
661: /* Radar 1670762 RESULT(ioReturn); */
662: return (ioReturn);
663: }
664:
665: /**
666: * Called by clients and user-interaction to retrieve information from
667: * the device. Note that non-privileged clients can call getIntValues
668: * and it may be used to *set* timestamp parameters.
669: */
670: - (IOReturn) getIntValues
671: : (unsigned *) parameterArray
672: forParameter : (IOParameterName) parameterName
673: count : (unsigned *) count; /* in/out */
674: {
675: IOReturn ioReturn = IO_R_INVALID_ARG;
676:
677: /* Radar 1670762 ENTRY("Sgi getIntValues"); */
678: if (strcmp(parameterName, APPLE96_AUTOSENSE) == 0) {
679: if (*count == 1) {
680: parameterArray[0] = gOptionAutoSenseEnable;
681: ioReturn = IO_R_SUCCESS;
682: }
683: }
684: else if (strcmp(parameterName, APPLE96_CMD_QUEUE) == 0) {
685: if (*count == 1) {
686: parameterArray[0] = gOptionCmdQueueEnable;
687: ioReturn = IO_R_SUCCESS;
688: }
689: }
690: else if (strcmp(parameterName, APPLE96_SYNC) == 0) {
691: if (*count == 1) {
692: parameterArray[0] = gOptionSyncModeEnable;
693: ioReturn = IO_R_SUCCESS;
694: }
695: }
696: else if (strcmp(parameterName, APPLE96_FAST_SCSI) == 0) {
697: if (*count == 1) {
698: parameterArray[0] = gOptionFastModeEnable;
699: ioReturn = IO_R_SUCCESS;
700: }
701: }
702: else if (strcmp(parameterName, APPLE96_ENABLE_DISCONNECT) == 0) { /* Radar 2005639 */
703: if (*count == 1) {
704: parameterArray[0] = gOptionDisconnectEnable;
705: ioReturn = IO_R_SUCCESS;
706: }
707: }
708: else if (strcmp(parameterName, APPLE_MAX_THREADS) == 0) { /* Radar 2005639 */
709: if (*count == 1) {
710: parameterArray[0] = MAX_CLIENT_THREADS;
711: ioReturn = IO_R_SUCCESS;
712: }
713: }
714: else if (strcmp(parameterName, APPLE96_RESET_TIMESTAMP) == 0) {
715: ResetTimestampIndex();
716: ioReturn = IO_R_SUCCESS;
717: }
718: else if (strcmp(parameterName, APPLE96_ENABLE_TIMESTAMP) == 0) {
719: EnableTimestamp(TRUE);
720: ioReturn = IO_R_SUCCESS;
721: }
722: else if (strcmp(parameterName, APPLE96_DISABLE_TIMESTAMP) == 0) {
723: EnableTimestamp(FALSE);
724: ioReturn = IO_R_SUCCESS;
725: }
726: else if (strcmp(parameterName, APPLE96_PRESERVE_FIRST_TIMESTAMP) == 0) {
727: PreserveTimestamp(TRUE);
728: ioReturn = IO_R_SUCCESS;
729: }
730: else if (strcmp(parameterName, APPLE96_PRESERVE_LAST_TIMESTAMP) == 0) {
731: PreserveTimestamp(FALSE);
732: ioReturn = IO_R_SUCCESS;
733: }
734: else if (strcmp(parameterName, APPLE96_STORE_TIMESTAMP) == 0) {
735: /*
736: * Count
737: * 1: tag, <zero>, current time
738: * 2: tag, value, current time
739: * 4: tag, value, user's time
740: */
741: switch (*count) {
742: case 1:
743: StoreTimestamp(parameterArray[0], 0);
744: ioReturn = IO_R_SUCCESS;
745: break;
746: case 2:
747: StoreTimestamp(parameterArray[0], parameterArray[1]);
748: ioReturn = IO_R_SUCCESS;
749: break;
750: case 4:
751: StoreNSecTimestamp(
752: parameterArray[0],
753: parameterArray[1],
754: *((ns_time_t *) ¶meterArray[2])
755: );
756: ioReturn = IO_R_SUCCESS;
757: break;
758: default:
759: break; /* Failure */
760: }
761: }
762: else if (strcmp(parameterName, APPLE96_READ_TIMESTAMP) == 0) {
763: /*
764: * Read the timestamp array:
765: * parameterArray -> result buffer (TimestampDataRecord vector)
766: * count -> maximum number of integers to return
767: * <- set to the actual number of integers returned.
768: * Note that, because count is a number of integers, clients should
769: * call this as follows:
770: * TimestampDataRecord myTimestamps[123];
771: * unsigned count;
772: * count = sizeof (myTimestamps) / sizeof (unsigned);
773: * [scsiDevice getIntValues
774: * : (unsigned int *) myTimestamps
775: * forParameter : APPLE96_READ_TIMESTAMP
776: * count : &count
777: * ];
778: * count = (count * sizeof (unsigned)) / sizeof (TimestampDataRecord);
779: * for (i = 0; i < count; i++) {
780: * Process(myTimestamps[i]);
781: * }
782: */
783: unsigned vectorSize = ((*count) * sizeof(unsigned))
784: / sizeof (TimestampDataRecord);
785: ReadTimestampVector((TimestampDataPtr) parameterArray, &vectorSize);
786: *count = (vectorSize * sizeof (TimestampDataRecord))
787: / sizeof (unsigned);
788: ioReturn = IO_R_SUCCESS;
789: }
790: else {
791: ioReturn = [super getIntValues : parameterArray
792: forParameter : parameterName
793: count : count];
794: }
795: /* RESULT(ioReturn); */
796: return (ioReturn);
797: }
798:
799:
800: #endif /* APPLE96_ENABLE_GET_SET */
801:
802: @end /* Apple96_SCSI */
803:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.