![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOFWLocalROM.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOFireWire|
Return to IOFWLocalROM.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOFireWire |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: * 3 June 99 wgulland created.
27: *
28: * IOFireWireController methods to build the local device ROM.
29: */
30:
31: #include <assert.h>
32:
33: #define DEBUGGING_LEVEL 0 // 1 = low; 2 = high; 3 = extreme
34: #define DEBUGLOG kprintf
35:
36: #include <IOKit/IOWorkLoop.h>
37: #include <IOKit/firewire/IOFireWireController.h>
38: #include <IOKit/firewire/IOFWCommand.h>
39: #include <IOKit/firewire/IOFireWireDevice.h>
40:
41: static void FWCSRROMDisposeLeafEntryData(CSRROMEntryDataPtr pCSRROMEntryData);
42: static void FWCSRROMDisposeEntryData(CSRROMEntryDataPtr pCSRROMEntryData);
43:
44:
45: ////////////////////////////////////////////////////////////////////////////////
46: //
47: // FWCSRROMCreateDirectoryEntryData
48: //
49: // Create a local directory entry data record.
50: //
51:
52: static IOReturn FWCSRROMCreateDirectoryEntryData(
53: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData,
54: CSRROMEntryDataPtr *ppCSRROMEntryData,
55: UInt32 entryKeyValue)
56: {
57: CSRROMDirectoryDataPtr pCSRROMDirectoryData;
58: IOReturn status = kIOReturnSuccess;
59:
60: // Allocate memory for entry data record.
61: pCSRROMDirectoryData =
62: (CSRROMDirectoryDataPtr) IOMalloc (sizeof (CSRROMDirectoryData));
63: if (pCSRROMDirectoryData == NULL)
64: status = kIOReturnNoMemory;
65:
66: // Fill in entry data record fields.
67: if (status == kIOReturnSuccess) {
68: // Copy parent's FWIM.
69: //pCSRROMDirectoryData->csrROMEntryData.fwimID =
70: // pParentCSRROMDirectoryData->csrROMEntryData.fwimID;
71:
72: // Set entry type and key value.
73: pCSRROMDirectoryData->csrROMEntryData.entryType = kDirectoryCSRROMEntryType;
74: pCSRROMDirectoryData->csrROMBasicEntryData.keyValue = entryKeyValue;
75:
76: // Fill in entry data.
77: pCSRROMDirectoryData->pChildCSRROMEntryData = NULL;
78: pCSRROMDirectoryData->numChildren = 0;
79: }
80:
81: // Return results.
82: if (status == kIOReturnSuccess)
83: *ppCSRROMEntryData = (CSRROMEntryDataPtr) pCSRROMDirectoryData;
84: else
85: *ppCSRROMEntryData = NULL;
86:
87: return (status);
88: }
89:
90: ////////////////////////////////////////////////////////////////////////////////
91: //
92: // FWCSRROMCreateImmediateEntryData
93: //
94: // Create a local immediate entry data record.
95: //
96:
97: static IOReturn FWCSRROMCreateImmediateEntryData(
98: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData,
99: CSRROMEntryDataPtr *ppCSRROMEntryData,
100: UInt32 entryKeyValue,
101: UInt8 * pEntryData)
102: {
103: CSRROMImmediateDataPtr pCSRROMImmediateData;
104: IOReturn status = kIOReturnSuccess;
105:
106: // Allocate memory for entry data record.
107: pCSRROMImmediateData =
108: (CSRROMImmediateDataPtr) IOMalloc (sizeof (CSRROMImmediateData));
109: if (pCSRROMImmediateData == NULL)
110: status = kIOReturnNoMemory;
111:
112: // Fill in entry data record fields.
113: if (status == kIOReturnSuccess) {
114: // Copy parent's FWIM.
115: //pCSRROMImmediateData->csrROMEntryData.fwimID =
116: // pParentCSRROMDirectoryData->csrROMEntryData.fwimID;
117:
118: // Set entry type and key value.
119: pCSRROMImmediateData->csrROMEntryData.entryType = kImmediateCSRROMEntryType;
120: pCSRROMImmediateData->csrROMBasicEntryData.keyValue = entryKeyValue;
121:
122: // Fill in entry data.
123: pCSRROMImmediateData->immediateData = (*((UInt32 *) pEntryData)) >> 8;
124: }
125:
126: // Return results.
127: if (status == kIOReturnSuccess)
128: *ppCSRROMEntryData = (CSRROMEntryDataPtr) pCSRROMImmediateData;
129: else
130: *ppCSRROMEntryData = NULL;
131:
132: return (status);
133: }
134:
135: ////////////////////////////////////////////////////////////////////////////////
136: //
137: // FWCSRROMCreateLeafEntryData
138: //
139: // Create a local leaf entry data record.
140: //
141:
142: static IOReturn FWCSRROMCreateLeafEntryData(
143: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData,
144: CSRROMEntryDataPtr *ppCSRROMEntryData,
145: UInt32 entryKeyValue,
146: UInt8 * pEntryData,
147: UInt32 entrySize)
148: {
149: CSRROMLeafDataPtr pCSRROMLeafData = NULL;
150: UInt8 * leafStorage;
151: UInt32 leafDataSize;
152: IOReturn status = kIOReturnSuccess;
153:
154: // Allocate memory for entry data record.
155: pCSRROMLeafData = (CSRROMLeafDataPtr) IOMalloc (sizeof (CSRROMLeafData));
156: if (pCSRROMLeafData == NULL)
157: status = kIOReturnNoMemory;
158:
159: // Allocate leaf storage.
160: if (status == kIOReturnSuccess) {
161: leafDataSize = (entrySize + 3) & (~0x03);
162: leafStorage = (UInt8 *)IOMalloc (leafDataSize);
163: if (leafStorage != NULL) {
164: *((UInt32 *) (leafStorage + leafDataSize - 4)) = 0;
165: pCSRROMLeafData->leafData = leafStorage;
166: pCSRROMLeafData->leafDataSize = leafDataSize;
167: }
168: else
169: status = kIOReturnNoMemory;
170: }
171:
172: // Fill in entry data record fields.
173: if (status == kIOReturnSuccess) {
174: // Copy parent's FWIM.
175: //pCSRROMLeafData->csrROMEntryData.fwimID =
176: // pParentCSRROMDirectoryData->csrROMEntryData.fwimID;
177:
178: // Set entry type and key value.
179: pCSRROMLeafData->csrROMEntryData.entryType = kLeafCSRROMEntryType;
180: pCSRROMLeafData->csrROMBasicEntryData.keyValue = entryKeyValue;
181:
182: // Fill in entry data.
183: bcopy (pEntryData, pCSRROMLeafData->leafData, entrySize);
184: }
185:
186: // Clean up on error.
187: if (status != kIOReturnSuccess) {
188: if (pCSRROMLeafData != NULL)
189: FWCSRROMDisposeLeafEntryData ((CSRROMEntryDataPtr) pCSRROMLeafData);
190: }
191:
192: // Return results.
193: if (status == kIOReturnSuccess)
194: *ppCSRROMEntryData = (CSRROMEntryDataPtr) pCSRROMLeafData;
195: else
196: *ppCSRROMEntryData = NULL;
197:
198: return (status);
199: }
200:
201:
202: ////////////////////////////////////////////////////////////////////////////////
203: //
204: // FWCSRROMCreateOffsetEntryData
205: //
206: // Create a local offset entry data record.
207: //
208:
209: static IOReturn FWCSRROMCreateOffsetEntryData(
210: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData,
211: CSRROMEntryDataPtr *ppCSRROMEntryData,
212: UInt32 entryKeyValue,
213: FWAddressPtr pFWAddress)
214: {
215: CSRROMOffsetDataPtr pCSRROMOffsetData;
216: IOReturn status = kIOReturnSuccess;
217:
218: // Check address range and alignment.
219: if ((pFWAddress->addressHi != kCSRRegisterSpaceBaseAddressHi) ||
220: (pFWAddress->addressLo < kCSRROMBaseAddress) ||
221: (pFWAddress->addressLo >= 0xF4000000)) {
222: status = kIOReturnBadArgument;
223: }
224: else if ((pFWAddress->addressLo & 0x03) != 0) {
225: status = kIOReturnNotAligned;
226: }
227:
228: // Allocate memory for entry data record.
229: if (status == kIOReturnSuccess) {
230: pCSRROMOffsetData =
231: (CSRROMOffsetDataPtr) IOMalloc (sizeof (CSRROMOffsetData));
232: if (pCSRROMOffsetData == NULL)
233: status = kIOReturnNoMemory;
234: }
235:
236: // Fill in entry data record fields.
237: if (status == kIOReturnSuccess) {
238: // Copy parent's FWIM.
239: //pCSRROMOffsetData->csrROMEntryData.fwimID =
240: // pParentCSRROMDirectoryData->csrROMEntryData.fwimID;
241:
242: // Set entry type and key value.
243: pCSRROMOffsetData->csrROMEntryData.entryType = kOffsetCSRROMEntryType;
244: pCSRROMOffsetData->csrROMBasicEntryData.keyValue = entryKeyValue;
245:
246: // Fill in entry data.
247: pCSRROMOffsetData->address = pFWAddress->addressLo;
248: }
249:
250: // Return results.
251: if (status == kIOReturnSuccess)
252: *ppCSRROMEntryData = (CSRROMEntryDataPtr) pCSRROMOffsetData;
253: else
254: *ppCSRROMEntryData = NULL;
255:
256: return (status);
257: }
258:
259: ////////////////////////////////////////////////////////////////////////////////
260: //
261: // FWCSRROMDisposeDirectoryEntryData
262: //
263: // Dispose of a local directory entry data record.
264: //
265:
266: static void FWCSRROMDisposeDirectoryEntryData(CSRROMEntryDataPtr pCSRROMEntryData)
267: {
268: CSRROMDirectoryDataPtr pCSRROMDirectoryData;
269: CSRROMEntryDataPtr pChildCSRROMEntryData, pNextCSRROMEntryData;
270: UInt32 numChildren, childNum;
271:
272: if (pCSRROMEntryData != NULL) {
273: // Recast entry data.
274: pCSRROMDirectoryData = (CSRROMDirectoryDataPtr) pCSRROMEntryData;
275:
276: // Deallocate all children entry data records.
277: pChildCSRROMEntryData = pCSRROMDirectoryData->pChildCSRROMEntryData;
278: numChildren = pCSRROMDirectoryData->numChildren;
279: for (childNum = 0; childNum < numChildren; childNum++) {
280: // Get next child entry data record.
281: pNextCSRROMEntryData = pChildCSRROMEntryData->pNextCSRROMEntryData;
282:
283: // Deallocate current child entry data record.
284: FWCSRROMDisposeEntryData (pChildCSRROMEntryData);
285:
286: // Go to next child entry data.
287: pChildCSRROMEntryData = pNextCSRROMEntryData;
288: }
289:
290: // Deallocate memory for entry data record.
291: IOFree(pCSRROMEntryData, sizeof(CSRROMDirectoryData));
292: }
293: }
294:
295: ////////////////////////////////////////////////////////////////////////////////
296: //
297: // FWCSRROMDisposeImmediateEntryData
298: //
299: // Dispose of a local immediate entry data record.
300: //
301:
302: static void FWCSRROMDisposeImmediateEntryData(CSRROMEntryDataPtr pCSRROMEntryData)
303: {
304: // Deallocate memory for entry data record.
305: if (pCSRROMEntryData != NULL)
306: IOFree (pCSRROMEntryData, sizeof(CSRROMImmediateData));
307: }
308:
309: ////////////////////////////////////////////////////////////////////////////////
310: //
311: // FWCSRROMDisposeLeafEntryData
312: //
313: // Dispose of a local leaf entry data record.
314: //
315:
316: static void FWCSRROMDisposeLeafEntryData(CSRROMEntryDataPtr pCSRROMEntryData)
317: {
318: CSRROMLeafDataPtr pCSRROMLeafData;
319: if (pCSRROMEntryData != NULL) {
320: // Recast entry data.
321: pCSRROMLeafData = (CSRROMLeafDataPtr) pCSRROMEntryData;
322:
323: // Deallocate leaf data storage.
324: if (pCSRROMLeafData->leafData != NULL)
325: IOFree(pCSRROMLeafData->leafData, pCSRROMLeafData->leafDataSize);
326:
327: // Deallocate memory for entry data record.
328: IOFree(pCSRROMEntryData, sizeof(CSRROMLeafData));
329: }
330: }
331:
332: ////////////////////////////////////////////////////////////////////////////////
333: //
334: // FWCSRROMDisposeOffsetEntryData
335: //
336: // Dispose of a local offset entry data record.
337: //
338:
339: static void FWCSRROMDisposeOffsetEntryData(CSRROMEntryDataPtr pCSRROMEntryData)
340: {
341: // Deallocate memory for entry data record.
342: if (pCSRROMEntryData != NULL)
343: IOFree (pCSRROMEntryData, sizeof(CSRROMOffsetData));
344: }
345:
346:
347: ////////////////////////////////////////////////////////////////////////////////
348: //
349: // FWCSRROMDisposeEntryData
350: //
351: // Dispose of a local entry data record.
352: //
353:
354: static void FWCSRROMDisposeEntryData(CSRROMEntryDataPtr pCSRROMEntryData)
355: {
356: if (pCSRROMEntryData != NULL) {
357: switch (pCSRROMEntryData->entryType) {
358: case kImmediateCSRROMEntryType :
359: FWCSRROMDisposeImmediateEntryData (pCSRROMEntryData);
360: break;
361:
362: case kOffsetCSRROMEntryType :
363: FWCSRROMDisposeOffsetEntryData (pCSRROMEntryData);
364: break;
365:
366: case kLeafCSRROMEntryType :
367: FWCSRROMDisposeLeafEntryData (pCSRROMEntryData);
368: break;
369:
370: case kDirectoryCSRROMEntryType :
371: FWCSRROMDisposeDirectoryEntryData (pCSRROMEntryData);
372: break;
373:
374: default :
375: break;
376: }
377: }
378: }
379:
380:
381: ////////////////////////////////////////////////////////////////////////////////
382: //
383: // FWCSRROMInsertEntryData
384: //
385: // This routine inserts a CSR ROM entry data record into the local CSR ROM
386: // tree.
387: //
388:
389: static void FWCSRROMInsertEntryData(
390: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData,
391: CSRROMEntryDataPtr pCSRROMEntryData)
392: {
393: CSRROMEntryDataPtr pFirstCSRROMEntryData, pPrevCSRROMEntryData, pNextCSRROMEntryData;
394:
395: // Get the first entry data record in the parent directory's list.
396: pFirstCSRROMEntryData = pParentCSRROMDirectoryData->pChildCSRROMEntryData;
397:
398: // Insert entry into list.
399: if (pFirstCSRROMEntryData != NULL) {
400: pPrevCSRROMEntryData = pFirstCSRROMEntryData->pPrevCSRROMEntryData;
401: pNextCSRROMEntryData = pFirstCSRROMEntryData;
402:
403: pPrevCSRROMEntryData->pNextCSRROMEntryData = pCSRROMEntryData;
404: pCSRROMEntryData->pPrevCSRROMEntryData = pPrevCSRROMEntryData;
405:
406: pNextCSRROMEntryData->pPrevCSRROMEntryData = pCSRROMEntryData;
407: pCSRROMEntryData->pNextCSRROMEntryData = pNextCSRROMEntryData;
408: }
409: else {
410: pParentCSRROMDirectoryData->pChildCSRROMEntryData = pCSRROMEntryData;
411:
412: pCSRROMEntryData->pPrevCSRROMEntryData = pCSRROMEntryData;
413: pCSRROMEntryData->pNextCSRROMEntryData = pCSRROMEntryData;
414: }
415:
416: pCSRROMEntryData->pParentCSRROMEntryData = (CSRROMEntryDataPtr) pParentCSRROMDirectoryData;
417: pParentCSRROMDirectoryData->numChildren++;
418: }
419:
420: ////////////////////////////////////////////////////////////////////////////////
421: //
422: // FWCSRROMEntrySize
423: //
424: // Calculate size of entry (including children)
425: //
426:
427: static int FWCSRROMEntrySize(CSRROMEntryDataPtr pCSRROMEntryData)
428: {
429: CSRROMEntryDataPtr pChildCSRROMEntryData;
430: CSRROMLeafDataPtr pCSRROMLeafData;
431: CSRROMDirectoryDataPtr pCSRROMDirectoryData;
432: UInt32 numChildren;
433: UInt32 i;
434: int size = 0;
435:
436: // Compute entry key type, value, and data.
437: switch (pCSRROMEntryData->entryType) {
438: case kImmediateCSRROMEntryType :
439: break;
440:
441: case kOffsetCSRROMEntryType :
442: break;
443:
444: case kLeafCSRROMEntryType :
445: pCSRROMLeafData = (CSRROMLeafDataPtr) pCSRROMEntryData;
446: size = (pCSRROMLeafData->leafDataSize >> 2) + 1;
447: break;
448:
449: case kDirectoryCSRROMEntryType :
450: pCSRROMDirectoryData = (CSRROMDirectoryDataPtr) pCSRROMEntryData;
451: numChildren = pCSRROMDirectoryData->numChildren;
452: size = 1;
453:
454: pChildCSRROMEntryData = pCSRROMDirectoryData->pChildCSRROMEntryData;
455: size += numChildren;
456: for (i = 0; i < numChildren; i++) {
457: size += FWCSRROMEntrySize(pChildCSRROMEntryData);
458: pChildCSRROMEntryData = pChildCSRROMEntryData->pNextCSRROMEntryData;
459: }
460:
461: break;
462:
463: default :
464: //zzz should we do anything on error?
465: break;
466: }
467:
468: return (size);
469: }
470:
471: ////////////////////////////////////////////////////////////////////////////////
472: //
473: // FWCSRROMInstantiateEntry
474: //
475: // Instantiate and entry in the local CSR ROM.
476: //
477:
478: static void FWCSRROMInstantiateEntry(CSRROMEntryDataPtr pCSRROMEntryData,
479: UInt32 **ppCSRROMStorage, UInt32 *pEntryLocation)
480: {
481: CSRROMEntryDataPtr pChildCSRROMEntryData;
482: CSRROMImmediateDataPtr pCSRROMImmediateData;
483: CSRROMOffsetDataPtr pCSRROMOffsetData;
484: CSRROMLeafDataPtr pCSRROMLeafData;
485: CSRROMDirectoryDataPtr pCSRROMDirectoryData;
486: UInt32 *pCSRROMStorage = *ppCSRROMStorage;
487: UInt32 *pCSRROMDirectoryStorage;
488: UInt32 *pHeader;
489: UInt32 crc16;
490: UInt32 entryOffset;
491: UInt32 entryValue;
492: UInt32 entryKeyType, entryKeyValue;
493: UInt32 numChildren;
494: UInt32 i;
495:
496: // Compute entry key type, value, and data.
497: switch (pCSRROMEntryData->entryType) {
498: case kImmediateCSRROMEntryType :
499: pCSRROMImmediateData = (CSRROMImmediateDataPtr) pCSRROMEntryData;
500: entryKeyType = kCSRImmediateKeyType;
501: entryKeyValue = pCSRROMImmediateData->csrROMBasicEntryData.keyValue;
502: entryValue = pCSRROMImmediateData->immediateData;
503: *pEntryLocation =
504: ((entryKeyType << kCSREntryKeyTypePhase) & kCSREntryKeyType) |
505: ((entryKeyValue << kCSREntryKeyValuePhase) & kCSREntryKeyValue) |
506: ((entryValue << kCSREntryValuePhase) & kCSREntryValue);
507: break;
508:
509: case kOffsetCSRROMEntryType :
510: pCSRROMOffsetData = (CSRROMOffsetDataPtr) pCSRROMEntryData;
511: entryKeyType = kCSROffsetKeyType;
512: entryKeyValue = pCSRROMOffsetData->csrROMBasicEntryData.keyValue;
513: entryOffset =
514: (pCSRROMOffsetData->address - kCSRRegisterSpaceBaseAddressLo) >> 2;
515: *pEntryLocation =
516: ((entryKeyType << kCSREntryKeyTypePhase) & kCSREntryKeyType) |
517: ((entryKeyValue << kCSREntryKeyValuePhase) & kCSREntryKeyValue) |
518: ((entryOffset << kCSREntryValuePhase) & kCSREntryValue);
519: break;
520:
521: case kLeafCSRROMEntryType :
522: pCSRROMLeafData = (CSRROMLeafDataPtr) pCSRROMEntryData;
523: entryKeyType = kCSRLeafKeyType;
524: entryKeyValue = pCSRROMLeafData->csrROMBasicEntryData.keyValue;
525: entryOffset = pCSRROMStorage - pEntryLocation;
526: *pEntryLocation =
527: ((entryKeyType << kCSREntryKeyTypePhase) & kCSREntryKeyType) |
528: ((entryKeyValue << kCSREntryKeyValuePhase) & kCSREntryKeyValue) |
529: ((entryOffset << kCSREntryValuePhase) & kCSREntryValue);
530:
531: crc16 = FWComputeCRC16 ((UInt32 *) pCSRROMLeafData->leafData,
532: pCSRROMLeafData->leafDataSize/4);
533:
534: *pCSRROMStorage++ =
535: (((pCSRROMLeafData->leafDataSize >> 2) << kCSRLeafDirLengthPhase) &
536: kCSRLeafDirLength) |
537: ((crc16 << kCSRLeafDirCRCPhase) & kCSRLeafDirCRC);
538:
539: bcopy(pCSRROMLeafData->leafData, pCSRROMStorage, pCSRROMLeafData->leafDataSize);
540: pCSRROMStorage =
541: (UInt32 *) ((UInt8 *) pCSRROMStorage + pCSRROMLeafData->leafDataSize);
542: break;
543:
544: case kDirectoryCSRROMEntryType :
545: pCSRROMDirectoryData = (CSRROMDirectoryDataPtr) pCSRROMEntryData;
546: entryKeyType = kCSRDirectoryKeyType;
547: entryKeyValue = pCSRROMDirectoryData->csrROMBasicEntryData.keyValue;
548: entryOffset = pCSRROMStorage - pEntryLocation;
549: if (pEntryLocation != NULL) {
550: *pEntryLocation =
551: ((entryKeyType << kCSREntryKeyTypePhase) & kCSREntryKeyType) |
552: ((entryKeyValue << kCSREntryKeyValuePhase) & kCSREntryKeyValue) |
553: ((entryOffset << kCSREntryValuePhase) & kCSREntryValue);
554: }
555:
556: numChildren = pCSRROMDirectoryData->numChildren;
557: pHeader = pCSRROMStorage;
558: pCSRROMStorage++;
559:
560: pChildCSRROMEntryData = pCSRROMDirectoryData->pChildCSRROMEntryData;
561: pCSRROMDirectoryStorage = pCSRROMStorage;
562: pCSRROMStorage += numChildren;
563: for (i = 0; i < numChildren; i++) {
564: FWCSRROMInstantiateEntry (pChildCSRROMEntryData, &pCSRROMStorage, pCSRROMDirectoryStorage++);
565: pChildCSRROMEntryData = pChildCSRROMEntryData->pNextCSRROMEntryData;
566: }
567:
568: crc16 = FWComputeCRC16 (pHeader + 1, numChildren);
569: *pHeader =
570: ((numChildren << kCSRLeafDirLengthPhase) & kCSRLeafDirLength) |
571: ((crc16 << kCSRLeafDirCRCPhase) & kCSRLeafDirCRC);
572:
573: break;
574:
575: default :
576: //zzz should we do anything on error?
577: break;
578: }
579:
580: // Update ROM storage.
581: *ppCSRROMStorage = pCSRROMStorage;
582: }
583:
584: ////////////////////////////////////////////////////////////////////////////////
585: //
586: // CSRROMGetRootDirectory
587: //
588: // Return the Entry ID of the root directory for our ROM.
589: //
590:
591: IOReturn IOFireWireController::CSRROMGetRootDirectory(CSRROMEntryID *pCSRROMEntryID)
592: {
593: CSRROMEntryID csrROMEntryID;
594: CSRROMEntryIDDataPtr pCSRROMEntryIDData;
595: CSRROMLocalIDDataPtr pCSRROMLocalIDData;
596: IOReturn status = kIOReturnSuccess;
597:
598: // Get the output entry ID and allocate if invalid.
599: csrROMEntryID = *pCSRROMEntryID;
600: if (csrROMEntryID == kInvalidCSRROMEntryID) {
601: csrROMEntryID = FWCSRROMCreateEntryID ();
602: if (csrROMEntryID == kInvalidCSRROMEntryID)
603: status = kIOReturnNoMemory;
604: }
605:
606: // Set to root directory.
607: if (status == kIOReturnSuccess) {
608: pCSRROMEntryIDData = (CSRROMEntryIDDataPtr) csrROMEntryID;
609: // Invalidate output entry ID type if it's not local.
610: if ((pCSRROMEntryIDData->entryType != kInvalidCSRROMEntryIDType) &&
611: (pCSRROMEntryIDData->entryType != kLocalCSRROMEntryIDType)) {
612: FWCSRROMInvalidateEntryIDType (csrROMEntryID);
613: }
614:
615: // Recast entry ID data.
616: pCSRROMLocalIDData = (CSRROMLocalIDDataPtr) pCSRROMEntryIDData;
617:
618: // Make entry ID reference local root directory.
619: pCSRROMLocalIDData->csrROMEntryIDData.entryType = kLocalCSRROMEntryIDType;
620: pCSRROMLocalIDData->pCSRROMEntryData =
621: (CSRROMEntryDataPtr) &fCSRROMRootDirectory;
622: *pCSRROMEntryID = csrROMEntryID;
623: }
624: return (status);
625: }
626:
627: ////////////////////////////////////////////////////////////////////////////////
628: //
629: // CSRROMCreateEntry
630: //
631: // Create an entry in the local CSR Configuration ROM.
632: //
633:
634: IOReturn IOFireWireController::CSRROMCreateEntry(
635: CSRROMEntryID parentCSRROMEntryID, CSRROMEntryID *pCSRROMEntryID,
636: UInt32 entryType, UInt32 entryKeyValue, void *entryData, UInt32 entrySize)
637: {
638: CSRROMEntryID csrROMEntryID;
639: CSRROMEntryIDDataPtr pCSRROMEntryIDData;
640: CSRROMLocalIDDataPtr pParentCSRROMLocalIDData;
641: CSRROMLocalIDDataPtr pCSRROMLocalIDData;
642: CSRROMDirectoryDataPtr pParentCSRROMDirectoryData;
643: CSRROMEntryDataPtr pNewCSRROMEntryData = NULL;
644: bool csrROMEntryIDAllocated = false;
645: IOReturn status = kIOReturnSuccess;
646:
647: // Get and validate parent directory.
648: pParentCSRROMLocalIDData = (CSRROMLocalIDDataPtr) parentCSRROMEntryID;
649: if (pParentCSRROMLocalIDData->csrROMEntryIDData.entryType == kLocalCSRROMEntryIDType) {
650: pParentCSRROMDirectoryData =
651: (CSRROMDirectoryDataPtr) pParentCSRROMLocalIDData->pCSRROMEntryData;
652: if (pParentCSRROMDirectoryData->csrROMEntryData.entryType != kDirectoryCSRROMEntryType)
653: status = kIOReturnBadArgument;
654: }
655: else {
656: status = kIOReturnBadArgument;
657: }
658:
659: // Get the output entry ID and allocate if invalid.
660: if (status == kIOReturnSuccess) {
661: csrROMEntryID = *pCSRROMEntryID;
662: if (csrROMEntryID == kInvalidCSRROMEntryID) {
663: csrROMEntryID = FWCSRROMCreateEntryID ();
664: if (csrROMEntryID != kInvalidCSRROMEntryID)
665: csrROMEntryIDAllocated = true;
666: else
667: status = kIOReturnNoMemory;
668: }
669:
670: if (csrROMEntryID != kInvalidCSRROMEntryID)
671: pCSRROMEntryIDData = (CSRROMEntryIDDataPtr) csrROMEntryID;
672: }
673:
674: // If output entry ID is not local, invalidate it.
675: if (status == kIOReturnSuccess) {
676: if ((pCSRROMEntryIDData->entryType != kInvalidCSRROMEntryIDType) &&
677: (pCSRROMEntryIDData->entryType != kLocalCSRROMEntryIDType)) {
678: FWCSRROMInvalidateEntryIDType (csrROMEntryID);
679: }
680: }
681:
682: // Create the requested type of entry data record.
683: if (status == kIOReturnSuccess) {
684: switch (entryType) {
685: case kImmediateCSRROMEntryType :
686: status = FWCSRROMCreateImmediateEntryData (pParentCSRROMDirectoryData,
687: &pNewCSRROMEntryData,
688: entryKeyValue,
689: (UInt8 *) entryData);
690: break;
691:
692: case kOffsetCSRROMEntryType :
693: status = FWCSRROMCreateOffsetEntryData (pParentCSRROMDirectoryData,
694: &pNewCSRROMEntryData,
695: entryKeyValue,
696: (FWAddressPtr) entryData);
697: break;
698:
699: case kLeafCSRROMEntryType :
700: status = FWCSRROMCreateLeafEntryData (pParentCSRROMDirectoryData,
701: &pNewCSRROMEntryData,
702: entryKeyValue,
703: (UInt8 *) entryData,
704: entrySize);
705: break;
706:
707: case kDirectoryCSRROMEntryType :
708: status = FWCSRROMCreateDirectoryEntryData (pParentCSRROMDirectoryData,
709: &pNewCSRROMEntryData,
710: entryKeyValue);
711: break;
712:
713: default :
714: status = kIOReturnBadArgument;
715: break;
716: }
717: }
718:
719: // Insert new entry into CSR Configuration ROM.
720: if (status == kIOReturnSuccess)
721: FWCSRROMInsertEntryData (pParentCSRROMDirectoryData, pNewCSRROMEntryData);
722:
723: // Set ID to reference new entry.
724: if (status == kIOReturnSuccess) {
725: pCSRROMLocalIDData = (CSRROMLocalIDDataPtr) pCSRROMEntryIDData;
726: pCSRROMLocalIDData->csrROMEntryIDData.entryType = kLocalCSRROMEntryIDType;
727: pCSRROMLocalIDData->pCSRROMEntryData = pNewCSRROMEntryData;
728: }
729:
730: // Clean up on error.
731: if (status != kIOReturnSuccess) {
732: if (pNewCSRROMEntryData != NULL)
733: FWCSRROMDisposeEntryData (pNewCSRROMEntryData);
734:
735: if (csrROMEntryIDAllocated)
736: FWCSRROMDisposeEntryID (csrROMEntryID);
737: }
738:
739: // Return results.
740: if (status == kIOReturnSuccess)
741: *pCSRROMEntryID = csrROMEntryID;
742:
743: return (status);
744: }
745:
746: ////////////////////////////////////////////////////////////////////////////////
747: //
748: // UpdateROM()
749: //
750: // Instantiate the local CSR ROM.
751: // Always causes at least one bus reset.
752: //
753:
754: IOReturn IOFireWireController::UpdateROM()
755: {
756: CSRROMDirectoryDataPtr pCSRROMDirectoryData;
757: CSRROMImmediateDataPtr pCSRROMImmediateData;
758: UInt32 *pCSRROMStorage;
759: UInt32 busInfoBlockSize;
760: UInt32 *pHeader;
761: UInt32 romSize;
762: UInt32 crc16;
763: OSData * rom;
764: IOReturn ret;
765:
766: // Update CSR ROM generation.
767: //zzz assumes first entry is generation value.
768: pCSRROMDirectoryData = &fCSRROMRootDirectory;
769: pCSRROMImmediateData =
770: (CSRROMImmediateDataPtr) pCSRROMDirectoryData->pChildCSRROMEntryData;
771: if (pCSRROMImmediateData->csrROMBasicEntryData.keyValue == kCSRGenerationKey)
772: pCSRROMImmediateData->immediateData++;
773:
774: busInfoBlockSize = (fROMHeader[0] & kCSRBusInfoBlockLength) >>
775: kCSRBusInfoBlockLengthPhase;
776: romSize = FWCSRROMEntrySize((CSRROMEntryDataPtr) pCSRROMDirectoryData) +
777: busInfoBlockSize;
778: kprintf("Rom size: %d\n", romSize);
779: rom = OSData::withCapacity((romSize+1)*4);
780: if(!rom)
781: return kIOReturnNoMemory;
782: pHeader = (UInt32 *)IOMalloc((romSize+1)*4);
783: if(!pHeader) {
784: rom->release();
785: return kIOReturnNoMemory;
786: }
787:
788: // Recursively build configuration ROM.
789: bcopy(fROMHeader, pHeader, 4*(busInfoBlockSize+1));
790: pCSRROMStorage = pHeader + busInfoBlockSize + 1;
791: FWCSRROMInstantiateEntry((CSRROMEntryDataPtr) pCSRROMDirectoryData,
792: &pCSRROMStorage, NULL);
793:
794: // Reconstruct Bus Info Block header.
795:
796: crc16 = FWComputeCRC16 (pHeader + 1, romSize);
797: *pHeader =
798: ((busInfoBlockSize << kCSRBusInfoBlockLengthPhase) & kCSRBusInfoBlockLength) |
799: ((romSize << kCSRROMCRCLengthPhase) & kCSRROMCRCLength) |
800: ((crc16 << kCSRROMCRCValuePhase) & kCSRROMCRCValue);
801: rom->appendBytes(pHeader, (romSize+1)*4);
802: IOFree(pHeader, (romSize+1)*4);
803: setProperty(gFireWireROM, rom);
804:
805: // If we have a FWIM that is fully FSL 1.1 compatible, use the set CSR ROM function.
806: // Otherwise just reset the bus.
807: #if 0
808: // Tell the FWIM to use this new CSR ROM data (and reset the bus)
809: //zzz Should support other (larger) ROM sizes
810: status = FWSetCSRROM (pHeader, (romSize+1)*4);
811: #endif
812: kprintf("old romspace: 0x%x\n", fROMAddrSpace);
813: if(fROMAddrSpace) {
814: freeAddress(fROMAddrSpace);
815: fROMAddrSpace->release();
816: fROMAddrSpace = NULL;
817: }
818: fROMAddrSpace = IOFWPseudoAddressSpace::simpleRead(
819: FWAddress(kCSRRegisterSpaceBaseAddressHi, kCSRROMBaseAddress),
820: (romSize+1)*4, rom->getBytesNoCopy());
821: ret = allocAddress(fROMAddrSpace);
822:
823: return (ret);
824: }
825:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.