]> git.saurik.com Git - apple/xnu.git/blame - iokit/Drivers/pci/drvApplePCI/AppleMacRiscPCI.cpp
projects / apple / xnu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xnu-124.13.tar.gz
[apple/xnu.git] / iokit / Drivers / pci / drvApplePCI / AppleMacRiscPCI.cpp
CommitLineData
1c79356b
A		 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
28 * by Fernando Urbina, Kent Miller.
29 *
30 */
31
32#include <IOKit/system.h>
33#include <ppc/proc_reg.h>
34
35#include <libkern/c++/OSContainers.h>
36#include <libkern/OSByteOrder.h>
37
38#include <IOKit/IODeviceMemory.h>
39#include <IOKit/IORangeAllocator.h>
40#include <IOKit/IODeviceTreeSupport.h>
41#include <IOKit/IOPlatformExpert.h>
42#include <IOKit/IOLib.h>
43#include <IOKit/assert.h>
44
45#include "AppleMacRiscPCI.h"
46
47#define ALLOC_AGP_RANGE 0
48
49/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
50
51#define super IOPCIBridge
52
53OSDefineMetaClassAndStructors(AppleMacRiscPCI, IOPCIBridge)
54
55OSDefineMetaClassAndStructors(AppleMacRiscVCI, AppleMacRiscPCI)
56
57OSDefineMetaClassAndStructors(AppleMacRiscAGP, AppleMacRiscPCI)
58
59/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
60
61bool AppleMacRiscPCI::start( IOService * provider )
62{
63 IOPCIPhysicalAddress ioAddrCell;
64 IOPhysicalAddress ioPhys;
65 IOPhysicalAddress ioPhysLen;
66 OSArray * array;
67 IODeviceMemory::InitElement rangeList[ 3 ];
68 IORegistryEntry * bridge;
69 OSData * busProp;
70
71 if( !IODTMatchNubWithKeys(provider, "('pci', 'vci')"))
72 return( false);
73
74 if( IODTMatchNubWithKeys(provider, "'uni-north'"))
75 configDataOffsetMask = 0x7;
76 else
77 configDataOffsetMask = 0x3;
78
79 if( 0 == (lock = IOSimpleLockAlloc()))
80 return( false );
81
82 ioAddrCell.physHi.bits = 0;
83 ioAddrCell.physHi.s.space = kIOPCIIOSpace;
84 ioAddrCell.physMid = 0;
85 ioAddrCell.physLo = 0;
86 ioAddrCell.lengthHi = 0;
87 ioAddrCell.lengthLo = 0x10000;
88
89 bridge = provider;
90
91 if( ! IODTResolveAddressCell( bridge, (UInt32 *) &ioAddrCell,
92 &ioPhys, &ioPhysLen) ) {
93
94 IOLog("%s: couldn't find my base\n", getName());
95 return( false);
96 }
97
98 /* define more explicit ranges */
99
100 rangeList[0].start = ioPhys;
101 rangeList[0].length = ioPhysLen;
102 rangeList[1].start = ioPhys + 0x00800000;
103 rangeList[1].length = 4;
104 rangeList[2].start = ioPhys + 0x00c00000;
105 rangeList[2].length = 4;
106
107 IORangeAllocator * platformRanges;
108 platformRanges = IOService::getPlatform()->getPhysicalRangeAllocator();
109 assert( platformRanges );
110 platformRanges->allocateRange( ioPhys, 0x01000000 );
111
112 array = IODeviceMemory::arrayFromList( rangeList, 3 );
113 if( !array)
114 return( false);
115
116 provider->setDeviceMemory( array );
117 array->release();
118 ioMemory = (IODeviceMemory *) array->getObject( 0 );
119
120 /* map registers */
121
122 if( (configAddrMap = provider->mapDeviceMemoryWithIndex( 1 )))
123 configAddr = (volatile UInt32 *) configAddrMap->getVirtualAddress();
124 if( (configDataMap = provider->mapDeviceMemoryWithIndex( 2 )))
125 configData = (volatile UInt8 *) configDataMap->getVirtualAddress();
126
127 if( !configAddr || !configData)
128 return( false);
129
130 busProp = (OSData *) bridge->getProperty("bus-range");
131 if( busProp)
132 primaryBus = *((UInt32 *) busProp->getBytesNoCopy());
133
134 return( super::start( provider));
135}
136
137bool AppleMacRiscPCI::configure( IOService * provider )
138{
139 UInt32 addressSelects;
140 UInt32 index;
141 bool ok;
142
143 addressSelects = configRead32( getBridgeSpace(), kMacRISCAddressSelect );
144
145 coarseAddressMask = addressSelects >> 16;
146 fineAddressMask = addressSelects & 0xffff;
147
148 for( index = 0; index < 15; index++ ) {
149 if( coarseAddressMask & (1 << index)) {
150 ok = addBridgeMemoryRange( index << 28, 0x10000000, true );
151 }
152 }
153
154// if( coarseAddressMask & (1 << 15)) // F segment
155 for( index = 0; index < 15; index++ ) {
156 if( fineAddressMask & (1 << index)) {
157 ok = addBridgeMemoryRange( (0xf0 | index) << 24,
158 0x01000000, true );
159 }
160 }
161
162 ok = addBridgeIORange( 0, 0x10000 );
163
164 return( super::configure( provider));
165}
166
167void AppleMacRiscPCI::free()
168{
169 if( configAddrMap)
170 configAddrMap->release();
171 if( configDataMap)
172 configDataMap->release();
173 if( lock)
174 IOSimpleLockFree( lock);
175
176 super::free();
177}
178
179IODeviceMemory * AppleMacRiscPCI::ioDeviceMemory( void )
180{
181 return( ioMemory);
182}
183
184IODeviceMemory * AppleMacRiscVCI::ioDeviceMemory( void )
185{
186 return( 0 );
187}
188
189bool AppleMacRiscVCI::configure( IOService * provider )
190{
191 addBridgeMemoryRange( 0x90000000, 0x10000000, true );
192
193 return( AppleMacRiscPCI::configure( provider));
194}
195
196UInt8 AppleMacRiscPCI::firstBusNum( void )
197{
198 return( primaryBus );
199}
200
201UInt8 AppleMacRiscPCI::lastBusNum( void )
202{
203 return( firstBusNum() );
204}
205
206IOPCIAddressSpace AppleMacRiscPCI::getBridgeSpace( void )
207{
208 IOPCIAddressSpace space;
209
210 space.bits = 0;
211 space.s.busNum = primaryBus;
212 space.s.deviceNum = kBridgeSelfDevice;
213
214 return( space );
215}
216
217inline bool AppleMacRiscPCI::setConfigSpace( IOPCIAddressSpace space,
218 UInt8 offset )
219{
220 UInt32 addrCycle;
221
222 offset &= 0xfc;
223 if( space.s.busNum == primaryBus) {
224
225 if( space.s.deviceNum < kBridgeSelfDevice)
226 return( false);
227
228 // primary config cycle
229 addrCycle = ( (1 << space.s.deviceNum)
230 | (space.s.functionNum << 8)
231 | offset );
232
233 } else {
234 // pass thru config cycle
235 addrCycle = ( (space.bits)
236 | offset
237 | 1 );
238 }
239
240 do {
241 OSWriteSwapInt32( configAddr, 0, addrCycle);
242 eieio();
243 } while( addrCycle != OSReadSwapInt32( configAddr, 0 ));
244 eieio();
245
246 return( true );
247}
248
249
250UInt32 AppleMacRiscPCI::configRead32( IOPCIAddressSpace space,
251 UInt8 offset )
252{
253 UInt32 data;
254 IOInterruptState ints;
255
256 ints = IOSimpleLockLockDisableInterrupt( lock );
257
258 if( setConfigSpace( space, offset )) {
259
260 offset = offset & configDataOffsetMask & 4;
261
262 data = OSReadSwapInt32( configData, offset );
263 eieio();
264
265 } else
266 data = 0xffffffff;
267
268 IOSimpleLockUnlockEnableInterrupt( lock, ints );
269
270 return( data );
271}
272
273void AppleMacRiscPCI::configWrite32( IOPCIAddressSpace space,
274 UInt8 offset, UInt32 data )
275{
276 IOInterruptState ints;
277
278 ints = IOSimpleLockLockDisableInterrupt( lock );
279
280 if( setConfigSpace( space, offset )) {
281
282 offset = offset & configDataOffsetMask & 4;
283
284 OSWriteSwapInt32( configData, offset, data );
285 eieio();
286 /* read to sync */
287 (void) OSReadSwapInt32( configData, offset );
288 eieio();
289 sync();
290 isync();
291 }
292
293 IOSimpleLockUnlockEnableInterrupt( lock, ints );
294}
295
296UInt16 AppleMacRiscPCI::configRead16( IOPCIAddressSpace space,
297 UInt8 offset )
298{
299 UInt16 data;
300 IOInterruptState ints;
301
302 ints = IOSimpleLockLockDisableInterrupt( lock );
303
304 if( setConfigSpace( space, offset )) {
305
306 offset = offset & configDataOffsetMask & 6;
307
308 data = OSReadSwapInt16( configData, offset );
309 eieio();
310
311 } else
312 data = 0xffff;
313
314 IOSimpleLockUnlockEnableInterrupt( lock, ints );
315
316 return( data );
317}
318
319void AppleMacRiscPCI::configWrite16( IOPCIAddressSpace space,
320 UInt8 offset, UInt16 data )
321{
322 IOInterruptState ints;
323
324 ints = IOSimpleLockLockDisableInterrupt( lock );
325
326 if( setConfigSpace( space, offset )) {
327
328 offset = offset & configDataOffsetMask & 6;
329
330 OSWriteSwapInt16( configData, offset, data );
331 eieio();
332 /* read to sync */
333 (void) OSReadSwapInt16( configData, offset );
334 eieio();
335 sync();
336 isync();
337 }
338
339 IOSimpleLockUnlockEnableInterrupt( lock, ints );
340}
341
342UInt8 AppleMacRiscPCI::configRead8( IOPCIAddressSpace space,
343 UInt8 offset )
344{
345 UInt16 data;
346 IOInterruptState ints;
347
348 ints = IOSimpleLockLockDisableInterrupt( lock );
349
350 if( setConfigSpace( space, offset )) {
351
352 offset = offset & configDataOffsetMask;
353
354 data = configData[ offset ];
355 eieio();
356
357 } else
358 data = 0xff;
359
360 IOSimpleLockUnlockEnableInterrupt( lock, ints );
361
362 return( data );
363}
364
365void AppleMacRiscPCI::configWrite8( IOPCIAddressSpace space,
366 UInt8 offset, UInt8 data )
367{
368 IOInterruptState ints;
369
370 ints = IOSimpleLockLockDisableInterrupt( lock );
371
372 if( setConfigSpace( space, offset )) {
373
374 offset = offset & configDataOffsetMask;
375
376 configData[ offset ] = data;
377 eieio();
378 /* read to sync */
379 data = configData[ offset ];
380 eieio();
381 sync();
382 isync();
383 }
384
385 IOSimpleLockUnlockEnableInterrupt( lock, ints );
386}
387
388/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
389
390#undef super
391#define super AppleMacRiscPCI
392
393/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
394
395bool AppleMacRiscAGP::configure( IOService * provider )
396{
397 if( !findPCICapability( getBridgeSpace(), kIOPCIAGPCapability, &targetAGPRegisters ))
398 return( false );
399
400 return( super::configure( provider));
401}
402
403IOPCIDevice * AppleMacRiscAGP::createNub( OSDictionary * from )
404{
405 IOPCIDevice * nub;
406 IOPCIAddressSpace space;
407 bool isAGP;
408 UInt8 masterAGPRegisters;
409
410 spaceFromProperties( from, &space);
411
412 isAGP = ( (space.s.deviceNum != getBridgeSpace().s.deviceNum)
413 && findPCICapability( space, kIOPCIAGPCapability, &masterAGPRegisters ));
414
415 if( isAGP) {
416 nub = new IOAGPDevice;
417 if( nub)
418 ((IOAGPDevice *)nub)->masterAGPRegisters = masterAGPRegisters;
419 from->setObject( kIOAGPBusFlagsKey, getProperty(kIOAGPBusFlagsKey));
420 } else
421 nub = super::createNub( from );
422
423 return( nub );
424}
425
426/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
427
428IOReturn AppleMacRiscAGP::createAGPSpace( IOAGPDevice * master,
429 IOOptionBits options,
430 IOPhysicalAddress * address,
431 IOPhysicalLength * length )
432{
433 IOReturn err;
434 IOPCIAddressSpace target = getBridgeSpace();
435 IOPhysicalLength agpLength;
436 IOPhysicalAddress gartPhys;
437
438 enum { agpSpacePerPage = 4 * 1024 * 1024 };
439 enum { agpBytesPerGartByte = 1024 };
440 enum { alignLen = 4 * 1024 * 1024 - 1 };
441
442 destroyAGPSpace( master );
443
444 agpLength = *length;
445 if( !agpLength)
446 agpLength = 32 * 1024 * 1024;
447
448 agpLength = (agpLength + alignLen) & ~alignLen;
449
450 err = kIOReturnVMError;
451 do {
452
453 gartLength = agpLength / agpBytesPerGartByte;
454 gartArray = (volatile UInt32 *) IOMallocContiguous(
455 gartLength, 4096, &gartPhys );
456 if( !gartArray)
457 continue;
458 // IOMapPages( kernel_map, gartArray, gartPhys, gartLength, kIOMapInhibitCache );
459 bzero( (void *) gartArray, gartLength);
460
461#if ALLOC_AGP_RANGE
462 IORangeAllocator * platformRanges
463 = getPlatform()->getPhysicalRangeAllocator();
464 for( agpBaseIndex = 0xf; agpBaseIndex > 0; agpBaseIndex--) {
465 systemBase = agpBaseIndex * 0x10000000;
466 if( platformRanges->allocateRange( systemBase, agpLength )) {
467 systemLength = agpLength;
468 break;
469 }
470 }
471#else
472 agpBaseIndex = 0;
473 systemBase = 0;
474 systemLength = agpLength;
475#endif
476 if( !systemLength)
477 continue;
478
479 agpRange = IORangeAllocator::withRange( agpLength, 4096 );
480 if( !agpRange)
481 continue;
482
483 *address = systemBase;
484 *length = systemLength;
485#if 0
486 coarseAddressMask |= (1 << agpBaseIndex);
487 configWrite32( target, kMacRISCAddressSelect,
488 (coarseAddressMask << 16) | fineAddressMask );
489#endif
490 configWrite32( target, kUniNAGP_BASE, agpBaseIndex << 28 );
491
492 assert( 0 == (gartPhys & 0xfff));
493 configWrite32( target, kUniNGART_BASE,
494 gartPhys | (agpLength / agpSpacePerPage));
495
496 err = kIOReturnSuccess;
497
498 } while( false );
499
500 if( kIOReturnSuccess == err)
501 setAGPEnable( master, true, 0 );
502 else
503 destroyAGPSpace( master );
504
505 return( err );
506}
507
508IOReturn AppleMacRiscAGP::getAGPSpace( IOAGPDevice * master,
509 IOPhysicalAddress * address,
510 IOPhysicalLength * length )
511{
512 if( systemLength) {
513
514 if( address)
515 *address = systemBase;
516 if( length)
517 *length = systemLength;
518 return( kIOReturnSuccess );
519
520 } else
521 return( kIOReturnNotReady );
522}
523
524IOReturn AppleMacRiscAGP::destroyAGPSpace( IOAGPDevice * master )
525{
526
527 setAGPEnable( master, false, 0 );
528
529 if( gartArray) {
530 IOFreeContiguous( (void *) gartArray, gartLength);
531 gartArray = 0;
532 }
533 if( agpRange) {
534 agpRange->release();
535 agpRange = 0;
536 }
537 if( systemLength) {
538#if ALLOC_AGP_RANGE
539 IORangeAllocator * platformRanges
540 = getPlatform()->getPhysicalRangeAllocator();
541 platformRanges->deallocate( systemBase, systemLength);
542#endif
543 systemLength = 0;
544 }
545
546 return( kIOReturnSuccess );
547}
548
549IORangeAllocator * AppleMacRiscAGP::getAGPRangeAllocator(
550 IOAGPDevice * master )
551{
552// if( agpRange) agpRange->retain();
553 return( agpRange );
554}
555
556IOOptionBits AppleMacRiscAGP::getAGPStatus( IOAGPDevice * master,
557 IOOptionBits options = 0 )
558{
559 IOPCIAddressSpace target = getBridgeSpace();
560
561 return( configRead32( target, kUniNINTERNAL_STATUS ) );
562}
563
564IOReturn AppleMacRiscAGP::resetAGPDevice( IOAGPDevice * master,
565 IOOptionBits options = 0 )
566{
567 IOReturn ret;
568
569 if( master->masterState & kIOAGPStateEnablePending) {
570 ret = setAGPEnable( master, true, 0 );
571 master->masterState &= ~kIOAGPStateEnablePending;
572 } else
573 ret = kIOReturnSuccess;
574
575 return( ret );
576}
577
578IOReturn AppleMacRiscAGP::commitAGPMemory( IOAGPDevice * master,
579 IOMemoryDescriptor * memory,
580 IOByteCount agpOffset,
581 IOOptionBits options = 0 )
582{
583 IOPCIAddressSpace target = getBridgeSpace();
584 IOReturn err = kIOReturnSuccess;
585 UInt32 offset = 0;
586 IOPhysicalAddress physAddr;
587 IOByteCount len;
588
589// ok = agpRange->allocate( memory->getLength(), &agpOffset );
590
591 assert( agpOffset < systemLength );
592 agpOffset /= (page_size / 4);
593 while( (physAddr = memory->getPhysicalSegment( offset, &len ))) {
594
595 offset += len;
596 len = (len + 0xfff) & ~0xfff;
597 while( len > 0) {
598 OSWriteLittleInt32( gartArray, agpOffset,
599 ((physAddr & ~0xfff) | 1));
600 agpOffset += 4;
601 physAddr += page_size;
602 len -= page_size;
603 }
604 }
605#if 1
606 flush_dcache( (vm_offset_t) gartArray, gartLength, false);
607 len = OSReadLittleInt32( gartArray, agpOffset - 4 );
608 sync();
609 isync();
610#endif
611
612 if( kIOAGPGartInvalidate & options) {
613 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
614 configWrite32( target, kUniNGART_CTRL, kGART_EN );
615 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
616 configWrite32( target, kUniNGART_CTRL, kGART_EN );
617 }
618
619 return( err );
620}
621
622IOReturn AppleMacRiscAGP::releaseAGPMemory( IOAGPDevice * master,
623 IOMemoryDescriptor * memory,
624 IOByteCount agpOffset,
625 IOOptionBits options )
626{
627 IOPCIAddressSpace target = getBridgeSpace();
628 IOReturn err = kIOReturnSuccess;
629 IOByteCount length;
630
631 if( !memory)
632 return( kIOReturnBadArgument );
633
634 length = memory->getLength();
635
636 if( (agpOffset + length) > systemLength)
637 return( kIOReturnBadArgument );
638
639// agpRange->deallocate( agpOffset, length );
640
641 length = (length + 0xfff) & ~0xfff;
642 agpOffset /= page_size;
643 while( length > 0) {
644 gartArray[ agpOffset++ ] = 0;
645 length -= page_size;
646 }
647#if 1
648 flush_dcache( (vm_offset_t) gartArray, gartLength, false);
649 length = OSReadLittleInt32( gartArray, 4 * (agpOffset - 1) );
650 sync();
651 isync();
652#endif
653
654 if( kIOAGPGartInvalidate & options) {
655 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
656 configWrite32( target, kUniNGART_CTRL, kGART_EN );
657 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
658 configWrite32( target, kUniNGART_CTRL, kGART_EN );
659 }
660
661 return( err );
662}
663
664IOReturn AppleMacRiscAGP::setAGPEnable( IOAGPDevice * _master,
665 bool enable, IOOptionBits options )
666{
667 IOReturn err = kIOReturnSuccess;
668 IOPCIAddressSpace target = getBridgeSpace();
669 IOPCIAddressSpace master = _master->space;
670 UInt32 command;
671 UInt32 targetStatus, masterStatus;
672 UInt8 masterAGPRegisters = _master->masterAGPRegisters;
673
674 if( enable) {
675
676 targetStatus = configRead32( target,
677 targetAGPRegisters + kIOPCIConfigAGPStatusOffset );
678 masterStatus = configRead32( master,
679 masterAGPRegisters + kIOPCIConfigAGPStatusOffset );
680
681 command = kIOAGPSideBandAddresssing
682 | kIOAGP4xDataRate | kIOAGP2xDataRate | kIOAGP1xDataRate;
683 command &= targetStatus;
684 command &= masterStatus;
685
686 if( command & kIOAGP4xDataRate)
687 command &= ~(kIOAGP2xDataRate | kIOAGP1xDataRate);
688 else if( command & kIOAGP2xDataRate)
689 command &= ~(kIOAGP1xDataRate);
690 else if( 0 == (command & kIOAGP1xDataRate))
691 return( kIOReturnUnsupported );
692
693 command |= kIOAGPEnable;
694
695 if( targetStatus > masterStatus)
696 targetStatus = masterStatus;
697 command |= (targetStatus & kIOAGPRequestQueueMask);
698
699#if 1
700 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
701 configWrite32( target, kUniNGART_CTRL, kGART_EN );
702 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
703 configWrite32( target, kUniNGART_CTRL, kGART_EN );
704#endif
705 do {
706 configWrite32( target, targetAGPRegisters + kIOPCIConfigAGPCommandOffset, command );
707 } while( (command & kIOAGPEnable) !=
708 (kIOAGPEnable & configRead32( target, targetAGPRegisters + kIOPCIConfigAGPCommandOffset)));
709
710 do {
711 configWrite32( master,
712 masterAGPRegisters + kIOPCIConfigAGPCommandOffset, command );
713 } while( (command & kIOAGPEnable) !=
714 (kIOAGPEnable & configRead32( master,
715 masterAGPRegisters + kIOPCIConfigAGPCommandOffset)));
716
717 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
718 configWrite32( target, kUniNGART_CTRL, kGART_EN );
719 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_2xRESET);
720 configWrite32( target, kUniNGART_CTRL, kGART_EN );
721
722 _master->masterState |= kIOAGPStateEnabled;
723
724 } else {
725
726 while( 0 == (kIOAGPIdle & configRead32( getBridgeSpace(),
727 kUniNINTERNAL_STATUS )))
728 {}
729
730 configWrite32( master, masterAGPRegisters + kIOPCIConfigAGPCommandOffset, 0 );
731 configWrite32( target, targetAGPRegisters + kIOPCIConfigAGPCommandOffset, 0 );
732#if 0
733 configWrite32( target, kUniNGART_CTRL, kGART_EN | kGART_INV );
734 configWrite32( target, kUniNGART_CTRL, 0 );
735 configWrite32( target, kUniNGART_CTRL, kGART_2xRESET);
736 configWrite32( target, kUniNGART_CTRL, 0 );
737#endif
738 _master->masterState &= ~kIOAGPStateEnabled;
739 }
740
741 return( err );
742}
743
744IOReturn AppleMacRiscAGP::saveDeviceState( IOPCIDevice * device,
745 IOOptionBits options = 0 )
746{
747 IOReturn ret;
748 IOAGPDevice * agpDev;
749 UInt32 agpSave[3];
750 IOPCIAddressSpace target = getBridgeSpace();
751
752 if( (agpDev = OSDynamicCast( IOAGPDevice, device))) {
753 agpSave[0] = configRead32( target, kUniNAGP_BASE );
754 agpSave[1] = configRead32( target, kUniNGART_BASE );
755 agpSave[2] = configRead32( target, targetAGPRegisters + kIOPCIConfigAGPCommandOffset );
756 setAGPEnable( agpDev, false, 0 );
757 }
758
759 ret = super::saveDeviceState( device, options);
760
761 if( agpDev && (ret == kIOReturnSuccess)) {
762 agpDev->savedConfig[ kUniNAGP_BASE / 4 ] = agpSave[0];
763 agpDev->savedConfig[ kUniNGART_BASE / 4 ] = agpSave[1];
764 agpDev->savedConfig[ (targetAGPRegisters + kIOPCIConfigAGPCommandOffset) / 4 ] = agpSave[2];
765 }
766
767 return( ret );
768}
769
770IOReturn AppleMacRiscAGP::restoreDeviceState( IOPCIDevice * device,
771 IOOptionBits options = 0 )
772{
773 IOReturn ret;
774 IOAGPDevice * agpDev;
775 UInt32 agpSave[3];
776 IOPCIAddressSpace target = getBridgeSpace();
777
778 agpDev = OSDynamicCast( IOAGPDevice, device);
779 if( agpDev && device->savedConfig) {
780 agpSave[0] = agpDev->savedConfig[ kUniNAGP_BASE / 4 ];
781 agpSave[1] = agpDev->savedConfig[ kUniNGART_BASE / 4 ];
782 agpSave[2] = agpDev->savedConfig[ (targetAGPRegisters + kIOPCIConfigAGPCommandOffset) / 4 ];
783 }
784
785 ret = super::restoreDeviceState( device, options);
786
787 if( agpDev && (kIOReturnSuccess == ret)) {
788 configWrite32( target, kUniNAGP_BASE, agpSave[0] );
789 configWrite32( target, kUniNGART_BASE, agpSave[1] );
790 // soon, grasshopper
791 if( kIOAGPEnable & agpSave[2])
792 agpDev->masterState |= kIOAGPStateEnablePending;
793 else
794 agpDev->masterState &= ~kIOAGPStateEnablePending;
795 }
796
797 return( ret );
798}
799
800/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
mirror of XNU