![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSIController.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel|
Return to IOSCSIController.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / Kernel |
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: * Copyright (c) 1991, 1992, 1993 NeXT Computer, Inc.
26: *
27: * Abstract superclass for SCSI controllers.
28: *
29: * HISTORY
30: *
31: * 1998-3-11 [email protected] Moved SCSI user to drvSCSIServer project.
32: * 12 December 1997 Martin Minow at Apple
33: * Added IOSCISUser kernel support
34: * 14 June 1995 Doug Mitchell at NeXT
35: * Added SCSI-3 support.
36: * 25 June 1993 David E. Bohman at NeXT
37: * Cleaned up some (made machine independent). Added this header.
38: * ?? ??? ???? Doug Mitchell at NeXT
39: * Created.
40: */
41:
42: #import <driverkit/IOSCSIController.h>
43: #import <machkit/NXLock.h>
44: #import <driverkit/return.h>
45: #import <driverkit/generalFuncs.h>
46: #import <driverkit/interruptMsg.h>
47: #import <driverkit/align.h>
48: #import <driverkit/xpr_mi.h>
49: #import <driverkit/kernelDriver.h>
50:
51: static int scUnitNum = 0;
52:
53: /*
54: * An element of _reserveQ.
55: */
56: typedef struct {
57: unsigned long long target;
58: unsigned long long lun;
59: id owner;
60: id lender;
61: queue_chain_t link;
62: } reserveElt;
63:
64: @interface IOSCSIController(private)
65:
66: - (reserveElt *) searchReserveQ: (unsigned long long) target
67: lun: (unsigned long long) lun;
68:
69: @end
70:
71: @implementation IOSCSIController
72:
73: - initFromDeviceDescription:deviceDescription
74: {
75: unsigned int target, lun;
76: char devName[20];
77: IODMAAlignment dmaAlign;
78:
79: queue_init(&_reserveQ);
80: if([[self class] deviceStyle] == IO_DirectDevice) {
81: /*
82: * Allow a subclass to act like an indirect device by
83: * skipping this stuff.
84: */
85: if ([super initFromDeviceDescription:deviceDescription] == nil)
86: return nil;
87:
88: if ([self startIOThread] != IO_R_SUCCESS) {
89: [self free]; return nil;
90: }
91: } else
92: [self setDeviceDescription:deviceDescription];
93:
94: /*
95: * We keep track of all scsi controllers in the system by number.
96: * Their device names look like 'scXX'. Note that the rest of the
97: * system actually LOOKS FOR sc0 instead of something more basic,
98: * so we're forced into using this scheme.
99: */
100: [self setUnit:scUnitNum];
101: sprintf(devName, "sc%d", scUnitNum++);
102: [self setName:devName];
103: [self setDeviceKind:"sc"];
104:
105: /*
106: * Determine worst case alignment requirement for this controller.
107: * The result will be used to do the alignment in
108: * allocateBufferOfLength.
109: */
110: [self getDMAAlignment:&dmaAlign];
111: _worstCaseAlign = dmaAlign.readStart;
112: if(dmaAlign.writeStart > _worstCaseAlign) {
113: _worstCaseAlign = dmaAlign.writeStart;
114: }
115: if(dmaAlign.readLength > _worstCaseAlign) {
116: _worstCaseAlign = dmaAlign.readLength;
117: }
118: if(dmaAlign.writeLength > _worstCaseAlign) {
119: _worstCaseAlign = dmaAlign.writeLength;
120: }
121: if(_worstCaseAlign == 1) {
122: _worstCaseAlign = 0;
123: }
124: return self;
125: }
126:
127:
128: - free
129: {
130: int size;
131: reserveElt *rsvElt;
132:
133: if(_reserveQ.next != NULL) {
134: /*
135: * Avoid if queue hasn't been init'd....
136: */
137: while(!queue_empty(&_reserveQ)) {
138: rsvElt = (reserveElt *)queue_first(&_reserveQ);
139: queue_remove(&_reserveQ, rsvElt, reserveElt *, link);
140: IOFree(rsvElt, sizeof(*rsvElt));
141: }
142: }
143:
144: /*
145: * If this is the last IOSCSIController to have been initialized,
146: * update the global unit counter.
147: */
148: if([self unit] == (scUnitNum - 1)) {
149: scUnitNum--;
150: }
151:
152: /* XXX what about the SCSIController thread?? */
153: return [super free];
154: }
155:
156: /*
157: * Release a reserved element for the owner
158: * _reserveLock held
159: */
160:
161: - (void) releaseReservationElement:(reserveElt *) rsvElt
162: {
163: id lender;
164:
165: lender = rsvElt->lender;
166: if( lender
167: && [lender respondsTo:@selector(reacquireTarget)]
168: && (IO_R_SUCCESS == [lender reacquireTarget]) ) {
169:
170: rsvElt->lender = nil;
171: rsvElt->owner = lender;
172:
173: } else {
174: queue_remove(&_reserveQ, rsvElt, reserveElt *, link);
175: IOFree(rsvElt, sizeof(*rsvElt));
176: _reserveCount--;
177: }
178: }
179:
180: /*
181: * Attempt to reserve specified target and lun for calling device. Returns
182: * non-zero if device already reserved.
183: *
184: * This is called by a client (e.g., SCSIDisk) in an attempt to mark a
185: * particular target/lun as being "in use" by that client; it's normally
186: * only used during SCSI bus configuration.
187: */
188:
189: - releaseAllUnitsForOwner: owner;
190: {
191: reserveElt *rsvElt, *nxtElt;
192:
193: [_reserveLock lock];
194:
195: rsvElt = (reserveElt *) queue_first(&_reserveQ);
196: while ( !queue_end(&_reserveQ, (queue_t) rsvElt) ) {
197: nxtElt = (reserveElt *) rsvElt->link.next;
198: if (rsvElt->owner == owner) {
199: [self releaseReservationElement:rsvElt];
200: }
201: rsvElt = nxtElt;
202: }
203:
204: [_reserveLock unlock];
205: }
206:
207: - (int) reserveTarget:(u_char)target lun:(u_char)lun forOwner:(id)owner
208: {
209: return [self reserveSCSI3Target:(unsigned long long)target
210: lun:(unsigned long long)lun
211: forOwner:owner];
212: }
213:
214:
215: - (void)releaseTarget:(u_char)target lun:(u_char)lun forOwner:(id)owner
216: {
217: [self releaseSCSI3Target:(unsigned long long)target
218: lun:(unsigned long long)lun
219: forOwner:owner];
220: }
221:
222: - (int)reserveSCSI3Target : (unsigned long long)target
223: lun : (unsigned long long)lun
224: forOwner : owner
225: {
226: int rtn = 0;
227: int targInt = target;
228: reserveElt *rsvElt;
229: id currentOwner;
230:
231: xpr_sdev("reserveSCSI3Target: t %x:%x l %x:%x\n",
232: (unsigned)(target >> 32),
233: (unsigned)target,
234: (unsigned)(lun >> 32),
235: (unsigned)lun, 5);
236: [_reserveLock lock];
237:
238: if(targInt >= [self numberOfTargets]) {
239: rtn = 1;
240: goto out;
241: }
242: rsvElt = [self searchReserveQ:target lun:lun];
243: if(rsvElt) {
244: xpr_sdev("...already reserved\n", 1,2,3,4,5);
245:
246: currentOwner = rsvElt->owner;
247: if( (rsvElt->lender == nil) // only 1 deep stack
248: && [currentOwner respondsTo:@selector(requestReleaseTarget)]
249: && (IO_R_SUCCESS == [currentOwner requestReleaseTarget]) ) {
250:
251: rsvElt->lender = currentOwner;
252: rsvElt->owner = owner;
253:
254: } else
255: rtn = 1;
256:
257: goto out;
258: }
259:
260: /*
261: * Cons up a new element for _reserveQ.
262: */
263: rsvElt = IOMalloc(sizeof(*rsvElt));
264: rsvElt->target = target;
265: rsvElt->lun = lun;
266: rsvElt->owner = owner;
267: rsvElt->lender = nil;
268: queue_enter(&_reserveQ, rsvElt, reserveElt *, link);
269: _reserveCount++;
270: out:
271: [_reserveLock unlock];
272: return(rtn);
273: }
274:
275: - (void)releaseSCSI3Target : (unsigned long long)target
276: lun : (unsigned long long)lun
277: forOwner : owner
278: {
279: int targInt = target;
280: reserveElt *rsvElt;
281:
282: xpr_sdev("releaseSCSI3Target: t %x:%x l %x:%x\n",
283: (unsigned)(target >> 32),
284: (unsigned)target,
285: (unsigned)(lun >> 32),
286: (unsigned)lun, 5);
287: [_reserveLock lock];
288: if(targInt >= [self numberOfTargets]) {
289: IOLog("IOSCSIController releaseTarget: INVALID TARGET\n");
290: goto out;
291: }
292: rsvElt = [self searchReserveQ:target lun:lun];
293: if(rsvElt == NULL) {
294: IOLog("IOSCSIController releaseTarget: NOT RESERVED\n");
295: goto out;
296: }
297: if(rsvElt->owner != owner) {
298: IOLog("IOSCSIController releaseTarget: INVALID OWNER\n");
299: goto out;
300: }
301:
302: [self releaseReservationElement:rsvElt];
303:
304: out:
305: [_reserveLock unlock];
306: }
307:
308:
309: /*
310: * Returns the number of SCSI targets supported. Default is 8, returned here.
311: * Subclasses may override if they support more than 8 targets.
312: */
313: - (int)numberOfTargets
314: {
315: return SCSI_NTARGETS;
316: }
317:
318: - (unsigned int) numReserved
319: {
320: return _reserveCount;
321: }
322:
323: - (sc_status_t) executeRequest : (IOSCSIRequest *)scsiReq
324: buffer : (void *)buffer /* data destination */
325: client : (vm_task_t)client
326: {
327: /*
328: * Subclass must implement this; we should never get here.
329: */
330: return SR_IOST_INVALID;
331: }
332:
333: /*
334: * executeRequest (with an IOMemoryDescriptor) requires buffers aligned to
335: * IO_SCSI_DMA_ALIGNMENT. The client identification is contained in the
336: * IOMemoryDescriptor object
337: */
338: - (sc_status_t) executeRequest : (IOSCSIRequest *) scsiReq
339: ioMemoryDescriptor : (IOMemoryDescriptor *) ioMemoryDescriptor
340: {
341: /*
342: * Subclass must implement this; we should never get here.
343: */
344: return SR_IOST_INVALID;
345: }
346:
347: - (sc_status_t) executeSCSI3Request : (IOSCSI3Request *)scsiReq
348: buffer : (void *)buffer /* data destination */
349: client : (vm_task_t)client
350: {
351: /*
352: * Optional.
353: */
354: return SR_IOST_CMDREJ;
355: }
356:
357: /*
358: * executeRequest (with an IOMemoryDescriptor) requires buffers aligned to
359: * IO_SCSI_DMA_ALIGNMENT. The client identification is contained in the
360: * IOMemoryDescriptor object
361: */
362: - (sc_status_t) executeSCSI3Request : (IOSCSI3Request *) scsiReq
363: ioMemoryDescriptor : (IOMemoryDescriptor *) ioMemoryDescriptor
364: {
365: /*
366: * Optional.
367: */
368: return SR_IOST_CMDREJ;
369: }
370:
371: - (sc_status_t) resetSCSIBus
372: {
373: return SR_IOST_INVALID;
374: }
375:
376: /*
377: * Convert an sc_status_t to an IOReturn.
378: */
379: - (IOReturn)returnFromScStatus:(sc_status_t)sc_status
380: {
381: switch(sc_status) {
382: case SR_IOST_GOOD:
383: return(IO_R_SUCCESS);
384: case SR_IOST_ALIGN:
385: return(IO_R_ALIGN);
386: case SR_IOST_CMDREJ:
387: return(IO_R_INVALID_ARG);
388: case SR_IOST_IPCFAIL:
389: return(IO_R_IPC_FAILURE);
390: case SR_IOST_INT:
391: return(IO_R_INTERNAL);
392: case SR_IOST_MEMF:
393: return(IO_R_VM_FAILURE);
394: case SR_IOST_MEMALL:
395: return(IO_R_RESOURCE);
396: case SR_IOST_DMA:
397: return(IO_R_DMA);
398: case SR_IOST_WP:
399: return(IO_R_NOT_WRITABLE);
400: default:
401: return(IO_R_IO);
402: }
403: }
404:
405:
406: /*
407: * Determine maximum DMA which can be peformed in a single call to
408: * executeRequest:buffer:client:.
409: */
410: - (unsigned)maxTransfer
411: {
412: return 16 * 1024 * 1024; /* XXX */
413: }
414:
415:
416: /*
417: * Return required DMA alignment for current architecture.
418: * May be overridden by subclass.
419: */
420: - (void)getDMAAlignment:(IODMAAlignment *)alignment
421: {
422: alignment->readStart = 1; /* XXX */
423: alignment->writeStart = 1; /* XXX */
424: alignment->readLength = 1; /* XXX */
425: alignment->writeLength = 1; /* XXX */
426: }
427:
428:
429:
430: - (unsigned int) numQueueSamples
431: {
432: return 0;
433: }
434:
435:
436: - (unsigned int) sumQueueLengths
437: {
438: return 0;
439: }
440:
441:
442: - (unsigned int) maxQueueLength
443: {
444: return 0;
445: }
446:
447:
448: - (void)resetStats
449: {
450: }
451:
452:
453: - (IOReturn)getIntValues:(unsigned *)parameterArray
454: forParameter:(IOParameterName)parameterName
455: count:(unsigned int *)count
456: {
457: unsigned maxCount = *count;
458: unsigned *returnedCount = count;
459:
460: unsigned int params[IO_SCSI_CONTROLLER_STAT_ARRAY_SIZE];
461: int i;
462: if(maxCount == 0) {
463: maxCount = IO_MAX_PARAMETER_ARRAY_LENGTH;
464: }
465: if(strcmp(parameterName, IO_SCSI_CONTROLLER_STATS) == 0) {
466: params[IO_SCSI_CONTROLLER_MAX_QUEUE_LENGTH] =
467: [self maxQueueLength];
468: params[IO_SCSI_CONTROLLER_QUEUE_SAMPLES] =
469: [self numQueueSamples];
470: params[IO_SCSI_CONTROLLER_QUEUE_TOTAL] =
471: [self sumQueueLengths];
472:
473: *returnedCount = 0;
474: for(i=0; i<IO_SCSI_CONTROLLER_STAT_ARRAY_SIZE; i++) {
475: if(*returnedCount == maxCount)
476: break;
477: parameterArray[i] = params[i];
478: (*returnedCount)++;
479: }
480: return IO_R_SUCCESS;
481: }
482: else if(strcmp(parameterName, IO_IS_A_SCSI_CONTROLLER) == 0) {
483: /*
484: * No data; just let caller know we're a disk.
485: */
486: *returnedCount = 0;
487: return IO_R_SUCCESS;
488: }
489: else {
490: return [super getIntValues:parameterArray
491: forParameter:parameterName
492: count:count];
493:
494: }
495: }
496:
497:
498: - (IOReturn)setIntValues:(unsigned *)parameterArray
499: forParameter:(IOParameterName)parameterName
500: count:(unsigned int)count
501: {
502: if(strcmp(parameterName, IO_SCSI_CONTROLLER_STATS) == 0) {
503: [self resetStats];
504: return IO_R_SUCCESS;
505: }
506: else
507: return [super setIntValues:parameterArray
508: forParameter:parameterName
509: count : count];
510: }
511:
512: /*
513: * Allocate some well-aligned memory. *actualStart is what has to be
514: * IOFree()'d eventually; *actualLength is the size arg to IOFree. The
515: * return value is the well-aligned pointer. There is room at the end of
516: * the returned pointer's buffer to do a DMA_DO_ALIGN(...,size,
517: * _worstCaseAlign).
518: */
519:
520: - (void *)allocateBufferOfLength: (unsigned)length
521: actualStart : (void **)actualStart
522: actualLength : (unsigned *)actualLength
523: {
524: char *cp;
525: int cnt = length + 2 * _worstCaseAlign;
526:
527: cp = IOMalloc(cnt);
528: *actualStart = cp;
529: *actualLength = cnt;
530: if(_worstCaseAlign > 1) {
531: return(IOAlign(void *, cp, _worstCaseAlign));
532: }
533: else {
534: return cp;
535: }
536: }
537:
538: - property_IODeviceClass:(char *)classes length:(unsigned int *)maxLen
539: {
540: strcpy( classes, IOClassSCSIController);
541: return( self);
542: }
543:
544: - property_IODeviceType:(char *)classes length:(unsigned int *)maxLen
545: {
546: if( [[self class] deviceStyle] == IO_DirectDevice)
547: strcat( classes, " "IOTypeSCSI);
548: return( self);
549: }
550:
551: @end
552:
553: @implementation IOSCSIController(private)
554:
555: /*
556: * Locate reserveElt for specified target and LUN. _reserveLock must be
557: * held on entry.
558: */
559: - (reserveElt *)searchReserveQ : (unsigned long long)target
560: lun : (unsigned long long)lun
561: {
562: reserveElt *rsvElt;
563:
564: rsvElt = (reserveElt *)queue_first(&_reserveQ);
565: while(!queue_end(&_reserveQ, (queue_t)rsvElt)) {
566: if((rsvElt->target == target) && (rsvElt->lun == lun)) {
567: return rsvElt;
568: }
569: rsvElt = (reserveElt *)rsvElt->link.next;
570: }
571: return NULL;
572: }
573:
574: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.