![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IdeDisk.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 IdeDisk.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: * IdeDisk.m - Exported methods for IDE Disk device class.
29: *
30: * HISTORY
31: * 07-Jul-1994 Rakesh Dubey at NeXT
32: * Created from original driver written by David Somayajulu.
33: */
34:
35: #import <driverkit/return.h>
36: #import <driverkit/driverTypes.h>
37: #import <driverkit/devsw.h>
38: #import <driverkit/generalFuncs.h>
39: #import <driverkit/kernelDiskMethods.h>
40: #import <driverkit/IODevice.h>
41: #import <machkit/NXLock.h>
42: #import <sys/systm.h>
43:
44: #import "IdeCnt.h"
45: #import "IdeDisk.h"
46: #import "IdeDiskInternal.h"
47: #import "IdeCntPublic.h"
48: #import "IdeKernel.h"
49:
50: //#define DEBUG
51:
52: static int diskUnit = 0;
53: static BOOL switchTableInited = NO;
54:
55: /*
56: * List of controllers that have been already probed. We need this since each
57: * Instance table lists IdeDisk as well as IdeController classes. And we need
58: * to create instances of disks attached to each controller only once.
59: */
60: static int probedControllerCount = 0;
61: static id probedControllers[MAX_IDE_CONTROLLERS];
62:
63: @implementation IdeDisk
64:
65: static Protocol *protocols[] = {
66: @protocol(IdeControllerPublic),
67: nil
68: };
69:
70: + (Protocol **)requiredProtocols
71: {
72: return protocols;
73: }
74:
75: + (IODeviceStyle)deviceStyle
76: {
77: return IO_IndirectDevice;
78: }
79:
80: /*
81: * IDE drives come with a built in controller on each drive. Hence we can
82: * have just one object per controller-disk pair. Probe is invoked at load
83: * time. It determines what drives are on the bus and alloc's and init:'s an
84: * instance of this class for each one.
85: *
86: */
87:
88: + (BOOL)probe : deviceDescription
89: {
90: id diskId;
91: IODevAndIdInfo *idMap = ide_idmap();
92: int unit, i;
93: id controllerId = [deviceDescription directDevice];
94:
95: #ifdef DEBUG
96: IOLog("IdeDisk probed with controller id %x\n", controllerId);
97: #endif DEBUG
98:
99: for (i = 0; i < probedControllerCount; i++) {
100: if (probedControllers[i] == controllerId) {
101: //IOLog("IdeDisk already probed for controller %x\n", controllerId);
102: return YES;
103: }
104: }
105: probedControllers[probedControllerCount++] = controllerId;
106: // IOLog("IdeDisk probing for controller %x\n", controllerId);
107:
108: for (unit = 0; unit < MAX_IDE_DRIVES; unit++) {
109:
110: diskId = [[IdeDisk alloc] initFromDeviceDescription:deviceDescription];
111: [diskId initResources:controllerId];
112: [diskId setDevAndIdInfo:&(idMap[diskUnit])];
113:
114: if ([diskId ideDiskInit:diskUnit target:unit] == NO) {
115: [diskId free];
116: continue;
117: }
118:
119: if (([self hd_devsw_init:deviceDescription]) == NO) {
120: [diskId free];
121: IOLog("IDEDisk: failed to add to devsw tables.\n");
122: return NO;
123: }
124:
125: /*
126: * Success; we initialized a drive. Have DiskObject superclass take
127: * care of the rest.
128: */
129: [diskId setDeviceKind:"IDEDisk"];
130: [diskId setIsPhysical:YES];
131: [diskId registerDevice];
132: diskUnit += 1;
133: }
134:
135: return YES;
136: }
137:
138: /*
139: * Add our entry to the device switch tables.
140: */
141: + (BOOL)hd_devsw_init:deviceDescription
142: {
143: extern int seltrue();
144:
145: /*
146: * We get called once for each IDE controller in the system; we
147: * only have to call IOAddToCdevsw() once.
148: */
149: if (switchTableInited == YES) {
150: return YES;
151: }
152:
153: if ([self addToCdevswFromDescription: deviceDescription
154: open: (IOSwitchFunc) ideopen
155: close: (IOSwitchFunc) ideclose
156: read: (IOSwitchFunc) ideread
157: write: (IOSwitchFunc) idewrite
158: ioctl: (IOSwitchFunc) ideioctl
159: stop: (IOSwitchFunc) eno_stop
160: reset: (IOSwitchFunc) nulldev
161: select: (IOSwitchFunc) seltrue
162: mmap: (IOSwitchFunc) eno_mmap
163: getc: (IOSwitchFunc) eno_getc
164: putc: (IOSwitchFunc) eno_putc] != YES)
165: {
166: return NO;
167: }
168:
169: if ([self addToBdevswFromDescription: deviceDescription
170: open: (IOSwitchFunc) ideopen
171: close: (IOSwitchFunc) ideclose
172: strategy: (IOSwitchFunc) idestrategy
173: ioctl: (IOSwitchFunc) ideioctl
174: dump: (IOSwitchFunc) eno_dump
175: psize: (IOSwitchFunc) idesize
176: isTape: FALSE] != YES)
177: {
178: return NO;
179: }
180:
181: ide_init_idmap(self);
182:
183: switchTableInited = YES;
184:
185: #ifdef undef
186: IOLog("IDE: block major %d, character major %d\n",
187: [self blockMajor], [self characterMajor]);
188: #endif undef
189:
190: return YES;
191: }
192:
193:
194: /*
195: * Common read/write methods. These are used directly in the kernel; user-level
196: * methods using remote objects as defined in IODevice.h in turn call these.
197: */
198: - (IOReturn) readAt : (unsigned)offset
199: length : (unsigned)length
200: buffer : (unsigned char *)buffer
201: actualLength : (unsigned *)actualLength
202: client : (vm_task_t)client
203: {
204: IOReturn rtn;
205:
206: rtn = [self deviceRwCommon : IDEC_READ
207: block : offset
208: length : length
209: buffer : buffer
210: client: client
211: pending : NULL
212: actualLength : actualLength];
213: return(rtn);
214: }
215:
216: - (IOReturn) readAsyncAt : (unsigned)offset
217: length : (unsigned)length
218: buffer : (unsigned char *)buffer
219: pending : (void *)pending
220: client : (vm_task_t)client
221: {
222: IOReturn rtn;
223:
224: rtn = [self deviceRwCommon : IDEC_READ
225: block : offset
226: length : length
227: buffer : buffer
228: client : client
229: pending : (void *)pending
230: actualLength : NULL];
231: return(rtn);
232: }
233:
234: - (IOReturn) writeAt : (unsigned)offset
235: length : (unsigned)length
236: buffer : (unsigned char *)buffer
237: actualLength : (unsigned *)actualLength
238: client : (vm_task_t)client
239: {
240: IOReturn rtn;
241:
242: rtn = [self deviceRwCommon : IDEC_WRITE
243: block : offset
244: length : length
245: buffer : buffer
246: client: client
247: pending : NULL
248: actualLength : actualLength];
249:
250: return(rtn);
251: }
252:
253: - (IOReturn) writeAsyncAt : (unsigned)offset
254: length : (unsigned)length
255: buffer : (unsigned char *)buffer
256: pending : (void *)pending
257: client : (vm_task_t)client
258: {
259: IOReturn rtn;
260:
261: rtn = [self deviceRwCommon : IDEC_WRITE
262: block : offset
263: length : length
264: buffer : buffer
265: client : client
266: pending : (void *)pending
267: actualLength : NULL];
268: return(rtn);
269: }
270:
271: - (IOReturn)updatePhysicalParameters
272: {
273: // we have got everything we need during initialization
274:
275: return(IO_R_SUCCESS);
276: }
277:
278: - (void)abortRequest
279: {
280: ideBuf_t *ideBuf;
281: IOReturn rtn;
282:
283: ideBuf = [self allocIdeBuf:NULL];
284: ideBuf->command = IDEC_ABORT;
285: ideBuf->buf = NULL;
286: ideBuf->needsDisk = 0;
287: ideBuf->oneWay = 0;
288: rtn = [self enqueueIdeBuf:ideBuf];
289: [self freeIdeBuf:ideBuf];
290: }
291:
292: - (void)diskBecameReady
293: {
294: [_ioQLock lock];
295: [_ioQLock unlockWith:WORK_AVAILABLE];
296: }
297:
298: - (IOReturn)isDiskReady : (BOOL)prompt
299: {
300: return(IO_R_SUCCESS);
301: }
302:
303: - (IODiskReadyState)updateReadyState
304: {
305: return([self lastReadyState]);
306: }
307:
308: - (IOReturn) ejectPhysical
309: {
310: return(IO_R_UNSUPPORTED);
311: }
312:
313: - (int)deviceOpen:(u_int)intentions
314: {
315: return(0);
316: }
317:
318: - (void)deviceClose
319: {
320: return;
321: }
322:
323: - (ideDriveInfo_t)ideGetDriveInfo
324: {
325: return(_ideInfo);
326: }
327:
328: - (id)cntrlr
329: {
330: return _cntrlr;
331: }
332:
333: - (unsigned)driveNum
334: {
335: return _driveNum;
336: }
337:
338: - (IOReturn)getIntValues:(unsigned int *)values
339: forParameter:(IOParameterName)parameter
340: count:(unsigned int *)count
341: {
342: int maxCount = *count;
343: int blockMajor, characterMajor;
344:
345: if (maxCount == 0) {
346: maxCount = IO_MAX_PARAMETER_ARRAY_LENGTH;
347: }
348:
349: if (strcmp(parameter, "BlockMajor") == 0) {
350: ide_block_char_majors(&blockMajor, &characterMajor);
351: values[0] = blockMajor;
352: *count = 1;
353: return IO_R_SUCCESS;
354: }
355: if (strcmp(parameter, "CharacterMajor") == 0) {
356: ide_block_char_majors(&blockMajor, &characterMajor);
357: values[0] = characterMajor;
358: *count = 1;
359: return IO_R_SUCCESS;
360: }
361:
362: /*
363: * Pass to superclass what we can't handle.
364: */
365: return [super getIntValues:values forParameter:parameter
366: count:&maxCount];
367: }
368:
369: - property_IOUnit:(char *)result length:(unsigned int *)maxLen
370: {
371: sprintf( result, "%d", [self driveNum]);
372: }
373:
374: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.