![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AppleMacRiscPCI.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / pci / drvApplePCI|
Return to AppleMacRiscPCI.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / pci / drvApplePCI |
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) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: * 23 Nov 98 sdouglas created from objc version.
27: * 05 Nov 99 sdouglas added UniNorth AGP based on UniNorthAGPDriver.c
* by Fernando Urbina, Kent Miller.
28: *
29: */
30:
31: #include <IOKit/system.h>
32: #include <ppc/proc_reg.h>
33:
34: #include <libkern/c++/OSContainers.h>
35: #include <libkern/OSByteOrder.h>
36:
37: #include <IOKit/IODeviceMemory.h>
38: #include <IOKit/IORangeAllocator.h>
39: #include <IOKit/IODeviceTreeSupport.h>
40: #include <IOKit/IOPlatformExpert.h>
41: #include <IOKit/IOLib.h>
42: #include <IOKit/assert.h>
43:
44: #include "AppleMacRiscPCI.h"
45:
46: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
47:
48: #define super IOPCIBridge
49:
50: OSDefineMetaClassAndStructors(AppleMacRiscPCI, IOPCIBridge)
51:
52: OSDefineMetaClassAndStructors(AppleMacRiscVCI, AppleMacRiscPCI)
53:
54: OSDefineMetaClassAndStructors(AppleMacRiscAGP, AppleMacRiscPCI)
55:
56: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
57:
58: bool AppleMacRiscPCI::start( IOService * provider )
59: {
60: IOPCIPhysicalAddress ioAddrCell;
61: IOPhysicalAddress ioPhys;
62: IOPhysicalAddress ioPhysLen;
63: OSArray * array;
64: IODeviceMemory::InitElement rangeList[ 3 ];
65: IORegistryEntry * bridge;
66: OSData * busProp;
67:
68: if( !IODTMatchNubWithKeys(provider, "('pci', 'vci')"))
69: return( false);
70:
71: if( IODTMatchNubWithKeys(provider, "'uni-north'"))
72: configDataOffsetMask = 0x7;
73: else
74: configDataOffsetMask = 0x3;
75:
76: if( 0 == (lock = IOSimpleLockAlloc()))
77: return( false );
78:
79: ioAddrCell.physHi.bits = 0;
80: ioAddrCell.physHi.s.space = kIOPCIIOSpace;
81: ioAddrCell.physMid = 0;
82: ioAddrCell.physLo = 0;
83: ioAddrCell.lengthHi = 0;
84: ioAddrCell.lengthLo = 0x10000;
85:
86: bridge = provider;
87:
88: if( ! IODTResolveAddressCell( bridge, (UInt32 *) &ioAddrCell,
89: &ioPhys, &ioPhysLen) ) {
90:
91: IOLog("%s: couldn't find my base\n", getName());
92: return( false);
93: }
94:
95: /* define more explicit ranges */
96:
97: rangeList[0].start = ioPhys;
98: rangeList[0].length = ioPhysLen;
99: rangeList[1].start = ioPhys + 0x00800000;
100: rangeList[1].length = 4;
101: rangeList[2].start = ioPhys + 0x00c00000;
102: rangeList[2].length = 4;
103:
104: IORangeAllocator * platformRanges;
105: platformRanges = IOService::getPlatform()->getPhysicalRangeAllocator();
106: assert( platformRanges );
107: platformRanges->allocateRange( ioPhys, 0x01000000 );
108:
109: array = IODeviceMemory::arrayFromList( rangeList, 3 );
110: if( !array)
111: return( false);
112:
113: provider->setDeviceMemory( array );
114: array->release();
115: ioMemory = (IODeviceMemory *) array->getObject( 0 );
116:
117: /* map registers */
118:
119: if( (configAddrMap = provider->mapDeviceMemoryWithIndex( 1 )))
120: configAddr = (volatile UInt32 *) configAddrMap->getVirtualAddress();
121: if( (configDataMap = provider->mapDeviceMemoryWithIndex( 2 )))
122: configData = (volatile UInt32 *) configDataMap->getVirtualAddress();
123:
124: if( !configAddr || !configData)
125: return( false);
126:
127: busProp = (OSData *) bridge->getProperty("bus-range");
128: if( busProp)
129: primaryBus = *((UInt32 *) busProp->getBytesNoCopy());
130:
131: return( super::start( provider));
132: }
133:
134: bool AppleMacRiscPCI::configure( IOService * provider )
135: {
136: UInt32 addressSelects;
137: UInt32 index;
138: bool ok;
139:
140: addressSelects = configRead32( getBridgeSpace(), kMacRISCAddressSelect );
141:
142: coarseAddressMask = addressSelects >> 16;
143: fineAddressMask = addressSelects & 0xffff;
144:
145: for( index = 0; index < 15; index++ ) {
146: if( coarseAddressMask & (1 << index)) {
147: ok = addBridgeMemoryRange( index << 28, 0x10000000, true );
148: }
149: }
150:
151: // if( coarseAddressMask & (1 << 15)) // F segment
152: for( index = 0; index < 15; index++ ) {
153: if( fineAddressMask & (1 << index)) {
154: ok = addBridgeMemoryRange( (0xf0 | index) << 24,
155: 0x01000000, true );
156: }
157: }
158:
159: ok = addBridgeIORange( 0, 0x10000 );
160:
161: return( super::configure( provider));
162: }
163:
164: void AppleMacRiscPCI::free()
165: {
166: if( configAddrMap)
167: configAddrMap->release();
168: if( configDataMap)
169: configDataMap->release();
170: if( lock)
171: IOSimpleLockFree( lock);
172:
173: super::free();
174: }
175:
176: IODeviceMemory * AppleMacRiscPCI::ioDeviceMemory( void )
177: {
178: return( ioMemory);
179: }
180:
181: IODeviceMemory * AppleMacRiscVCI::ioDeviceMemory( void )
182: {
183: return( 0 );
184: }
185:
186: bool AppleMacRiscVCI::configure( IOService * provider )
187: {
188: addBridgeMemoryRange( 0x90000000, 0x10000000, true );
189:
190: return( AppleMacRiscPCI::configure( provider));
191: }
192:
193: UInt8 AppleMacRiscPCI::firstBusNum( void )
194: {
195: return( primaryBus );
196: }
197:
198: UInt8 AppleMacRiscPCI::lastBusNum( void )
199: {
200: return( firstBusNum() );
201: }
202:
203: IOPCIAddressSpace AppleMacRiscPCI::getBridgeSpace( void )
204: {
205: IOPCIAddressSpace space;
206:
207: space.bits = 0;
208: space.s.busNum = primaryBus;
209: space.s.deviceNum = kBridgeSelfDevice;
210:
211: return( space );
212: }
213:
214: inline bool AppleMacRiscPCI::setConfigSpace( IOPCIAddressSpace space,
215: UInt8 offset )
216: {
217: UInt32 addrCycle;
218:
219: if( space.s.busNum == primaryBus) {
220:
221: if( space.s.deviceNum < kBridgeSelfDevice)
222: return( false);
223:
224: // primary config cycle
225: addrCycle = ( (1 << space.s.deviceNum)
226: | (space.s.functionNum << 8)
227: | offset );
228:
229: } else {
230: // pass thru config cycle
231: addrCycle = ( (space.bits)
232: | offset
233: | 1 );
234: }
235:
236: do {
237: OSWriteSwapInt32( configAddr, 0, addrCycle);
238: eieio();
239: } while( addrCycle != OSReadSwapInt32( configAddr, 0 ));
240: eieio();
241:
242: return( true );
243: }
244:
245:
246: UInt32 AppleMacRiscPCI::configRead32( IOPCIAddressSpace space,
247: UInt8 offset )
248: {
249: UInt32 data;
250: IOInterruptState ints;
251:
252: ints = IOSimpleLockLockDisableInterrupt( lock );
253:
254: if( setConfigSpace( space, offset )) {
255:
256: data = OSReadSwapInt32( configData, offset & configDataOffsetMask );
257: eieio();
258:
259: } else
260: data = 0xffffffff;
261:
262: IOSimpleLockUnlockEnableInterrupt( lock, ints );
263:
264: return( data );
265: }
266:
267: void AppleMacRiscPCI::configWrite32( IOPCIAddressSpace space,
268: UInt8 offset, UInt32 data )
269: {
270: IOInterruptState ints;
271:
272: ints = IOSimpleLockLockDisableInterrupt( lock );
273:
274: if( setConfigSpace( space, offset )) {
275:
276: OSWriteSwapInt32( configData, offset & configDataOffsetMask, data );
277: eieio();
278: /* read to sync (?) */
279: (void) OSReadSwapInt32( configData, offset & configDataOffsetMask );
280: eieio();
281: sync();
282: isync();
283: }
284:
285: IOSimpleLockUnlockEnableInterrupt( lock, ints );
286: }
287:
288: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
289:
290: #undef super
291: #define super AppleMacRiscPCI
292:
293: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
294:
295: bool AppleMacRiscAGP::configure( IOService * provider )
296: {
297: if( !findPCICapability( getBridgeSpace(), kIOPCIAGPCapability))
298: return( false );
299:
300: return( super::configure( provider));
301: }
302:
303: IOPCIDevice * AppleMacRiscAGP::createNub( OSDictionary * from )
304: {
305: IOPCIDevice * nub;
306: IOPCIAddressSpace space;
307: bool isAGP;
308:
309: spaceFromProperties( from, &space);
310:
311: isAGP = ( (space.s.deviceNum != getBridgeSpace().s.deviceNum)
312: && findPCICapability( space, kIOPCIAGPCapability));
313:
314: if( isAGP)
315: nub = new IOAGPDevice;
316: else
317: nub = super::createNub( from );
318:
319: return( nub );
320: }
321:
322: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
323:
324: IOReturn AppleMacRiscAGP::createAGPSpace( IOPCIAddressSpace master,
325: IOOptionBits options,
326: IOPhysicalAddress * address,
327: IOPhysicalLength * length )
328: {
329: IOReturn err;
330: IORangeAllocator * platformRanges;
331: IOPCIAddressSpace target = getBridgeSpace();
332: IOPhysicalLength agpLength;
333: IOPhysicalAddress gartPhys;
334:
335: enum { agpSpacePerPage = 4 * 1024 * 1024 };
336: enum { agpBytesPerGartByte = 1024 };
337: enum { alignLen = 4 * 1024 * 1024 - 1 };
338:
339: destroyAGPSpace( master );
340:
341: agpLength = *length;
342: if( !agpLength)
343: agpLength = 32 * 1024 * 1024;
344:
345: agpLength = (agpLength + alignLen) & ~alignLen;
346:
347: err = kIOReturnVMError;
348: do {
349:
350: gartLength = agpLength / agpBytesPerGartByte;
351: gartArray = (volatile UInt32 *) IOMallocContiguous(
352: gartLength, 4096, &gartPhys );
353: if( !gartArray)
354: continue;
355: //IOMapPages( kernel_map, gartArray, gartPhys, gartLength, kIOMapInhibitCache );
356: bzero( (void *) gartArray, gartLength);
357:
358: platformRanges = getPlatform()->getPhysicalRangeAllocator();
359:
360: for( agpBaseIndex = 0xf; agpBaseIndex > 0; agpBaseIndex--) {
361: systemBase = agpBaseIndex * 0x10000000;
362: if( platformRanges->allocateRange( systemBase, agpLength )) {
363: systemLength = agpLength;
364: break;
365: }
366: }
367: if( !systemLength)
368: continue;
369:
370: agpRange = IORangeAllocator::withRange( agpLength, 4096 );
371: if( !agpRange)
372: continue;
373:
374: *address = systemBase;
375: *length = systemLength;
376: #if 0
377: coarseAddressMask |= (1 << agpBaseIndex);
378: configWrite32( target, kMacRISCAddressSelect,
379: (coarseAddressMask << 16) | fineAddressMask );
380: #endif
381: configWrite32( target, kUniNAGP_BASE, agpBaseIndex << 28 );
382:
383: assert( 0 == (gartPhys & 0xfff));
384: configWrite32( target, kUniNGART_BASE,
385: gartPhys | (agpLength / agpSpacePerPage));
386:
387: err = kIOReturnSuccess;
388:
389: } while( false );
390:
391: if( kIOReturnSuccess == err)
392: setAGPEnable( master, true, 1 );
393: else
394: destroyAGPSpace( master );
395:
396: return( err );
397: }
398:
399: IOReturn AppleMacRiscAGP::destroyAGPSpace( IOPCIAddressSpace master )
400: {
401: IORangeAllocator * platformRanges;
402:
403: setAGPEnable( master, false, 0 );
404:
405: if( gartArray) {
406: IOFreeContiguous( (void *) gartArray, gartLength);
407: gartArray = 0;
408: }
409: if( agpRange) {
410: agpRange->release();
411: agpRange = 0;
412: }
413: if( systemLength) {
414: platformRanges = getPlatform()->getPhysicalRangeAllocator();
415: platformRanges->deallocate( systemBase, systemLength);
416: systemLength = 0;
417: }
418:
419: return( kIOReturnSuccess );
420: }
421:
422: IORangeAllocator * AppleMacRiscAGP::getAGPRangeAllocator(
423: IOPCIAddressSpace master )
424: {
425: // if( agpRange) agpRange->retain();
426: return( agpRange );
427: }
428:
429: IOOptionBits AppleMacRiscAGP::getAGPStatus( IOPCIAddressSpace master,
430: IOOptionBits options = 0 )
431: {
432: return( configRead32( getBridgeSpace(), kUniNINTERNAL_STATUS ) );
433: }
434:
435: IOReturn AppleMacRiscAGP::commitAGPMemory( IOPCIAddressSpace master,
436: IOMemoryDescriptor * memory,
437: IOByteCount agpOffset,
438: IOOptionBits options = 0 )
439: {
440: IOPCIAddressSpace target = getBridgeSpace();
441: IOReturn err = kIOReturnSuccess;
442: UInt32 offset = 0;
443: IOPhysicalAddress physAddr;
444: IOByteCount len;
445:
446: // ok = agpRange->allocate( memory->getLength(), &agpOffset );
447:
448: assert( agpOffset < systemLength );
449: agpOffset /= (page_size / 4);
450: while( (physAddr = memory->getPhysicalSegment( offset, &len ))) {
451:
452: offset += len;
453: len = (len + 0xfff) & ~0xfff;
454: while( len > 0) {
455: OSWriteLittleInt32( gartArray, agpOffset,
456: ((physAddr & ~0xfff) | 1));
457: agpOffset += 4;
458: physAddr += page_size;
459: len -= page_size;
460: }
461: }
462: flush_dcache( (vm_offset_t) gartArray, gartLength, false);
463: sync();
464: isync();
465: #if 1
466: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
467: configWrite32( target, kUniNGART_CTRL, kGART_EN );
468: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
469: configWrite32( target, kUniNGART_CTRL, kGART_EN );
470: #endif
471:
472: return( err );
473: }
474:
475: IOReturn AppleMacRiscAGP::releaseAGPMemory( IOPCIAddressSpace master,
476: IOMemoryDescriptor * memory,
477: IOByteCount agpOffset )
478: {
479: IOPCIAddressSpace target = getBridgeSpace();
480: IOReturn err = kIOReturnSuccess;
481: IOByteCount length;
482:
483: if( !memory)
484: return( kIOReturnBadArgument );
485:
486: length = memory->getLength();
487:
488: if( (agpOffset + length) >= systemLength)
489: return( kIOReturnBadArgument );
490:
491: // agpRange->deallocate( agpOffset, length );
492:
493: length = (length + 0xfff) & ~0xfff;
494: agpOffset /= page_size;
495: while( length > 0) {
496: gartArray[ agpOffset++ ] = 0;
497: length -= page_size;
498: }
499: flush_dcache( (vm_offset_t) gartArray, gartLength, false);
500: sync();
501: isync();
502:
503: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
504: configWrite32( target, kUniNGART_CTRL, kGART_EN );
505: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
506: configWrite32( target, kUniNGART_CTRL, kGART_EN );
507:
508: return( err );
509: }
510:
511: IOReturn AppleMacRiscAGP::setAGPEnable( IOPCIAddressSpace master,
512: bool enable, IOOptionBits options )
513: {
514: IOReturn err = kIOReturnSuccess;
515: IOPCIAddressSpace target = getBridgeSpace();
516: UInt32 command;
517: UInt32 targetStatus, masterStatus;
518:
519: if( enable) {
520:
521: targetStatus = configRead32( target, kIOPCIConfigAGPTargetStatus );
522: masterStatus = configRead32( master, kIOPCIConfigAGPMasterStatus );
523:
524: command = kIOAGPSideBandAddresssing
525: | kIOAGP4xDataRate | kIOAGP2xDataRate | kIOAGP1xDataRate;
526: command &= targetStatus;
527: command &= masterStatus;
528:
529: if( command & kIOAGP4xDataRate)
530: command &= ~(kIOAGP2xDataRate | kIOAGP1xDataRate);
531: else if( command & kIOAGP2xDataRate)
532: command &= ~(kIOAGP1xDataRate);
533:
534: command |= kIOAGPEnable;
535:
536: if( targetStatus > masterStatus)
537: targetStatus = masterStatus;
538: command |= (targetStatus & kIOAGPRequestQueueMask);
539:
540: #if 1
541: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
542: configWrite32( target, kUniNGART_CTRL, kGART_EN );
543: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
544: configWrite32( target, kUniNGART_CTRL, kGART_EN );
545: #endif
546: do {
547: configWrite32( target, kIOPCIConfigAGPTargetCommand, command );
548: } while( (command & kIOAGPEnable) !=
549: (kIOAGPEnable & configRead32( target, kIOPCIConfigAGPTargetCommand)));
550:
551: do {
552: configWrite32( master, kIOPCIConfigAGPMasterCommand, command );
553: } while( (command & kIOAGPEnable) !=
554: (kIOAGPEnable & configRead32( master, kIOPCIConfigAGPMasterCommand)));
555:
556: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
557: configWrite32( target, kUniNGART_CTRL, kGART_EN );
558: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
559: configWrite32( target, kUniNGART_CTRL, kGART_EN );
560:
561: } else {
562:
563: configWrite32( master, kIOPCIConfigAGPMasterCommand, 0 );
564: configWrite32( target, kIOPCIConfigAGPTargetCommand, 0 );
565: configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
566: configWrite32( target, kUniNGART_CTRL, 0 );
567: configWrite32( target, kUniNGART_CTRL, kGART_2xRESET);
568: configWrite32( target, kUniNGART_CTRL, 0 );
569: }
570:
571: return( err );
572: }
573:
574: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.