![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IONDRVFramebuffer.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport|
Return to IONDRVFramebuffer.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport |
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) 1997-1998 Apple Computer, Inc.
24: *
25: *
26: * HISTORY
27: *
28: * sdouglas 22 Oct 97 - first checked in.
29: * sdouglas 24 Jul 98 - start IOKit.
30: * sdouglas 15 Dec 98 - cpp.
31: *
32: */
33:
34: #include <IOKit/IOLib.h>
35: #include <IOKit/IOPlatformExpert.h>
36: #include <IOKit/IODeviceTreeSupport.h>
37: #include <IOKit/IOLocks.h>
38: #include <IOKit/ndrvsupport/IONDRVFramebuffer.h>
39: #include <IOKit/assert.h>
40:
41: #include <libkern/c++/OSContainers.h>
42:
43: #include "IONDRV.h"
44:
45: #include <string.h>
46:
47: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
48:
49: class IOATINDRV : public IONDRVFramebuffer
50: {
51: OSDeclareDefaultStructors(IOATINDRV)
52:
53: public:
54: virtual IOReturn getStartupDisplayMode( IODisplayModeID * displayMode,
55: IOIndex * depth );
56: virtual IODeviceMemory * findVRAM( void );
57:
58: };
59:
60: class IOATI128NDRV : public IOATINDRV
61: {
62: OSDeclareDefaultStructors(IOATI128NDRV)
63:
64: public:
65: virtual void flushCursor( void );
66: };
67:
68: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
69:
70: struct _VSLService {
71: class IONDRVFramebuffer * framebuffer;
72: IOSelect type;
73: IOFBInterruptProc handler;
74: OSObject * target;
75: void * ref;
76: _VSLService * next;
77: };
78:
79: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
80:
81: // frame buffer has two power states, off and on
82: #define number_of_power_states 2
83:
84: static IOPMPowerState ourPowerStates[number_of_power_states] = {
85: {1,0,0,0,0,0,0,0,0,0,0,0},
86: {1,IOPMDeviceUsable,IOPMPowerOn,IOPMPowerOn,0,0,0,0,0,0,0,0}
87: };
88:
89: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
90:
91: #define super IOFramebuffer
92:
93: OSDefineMetaClassAndStructors(IONDRVFramebuffer, IOFramebuffer)
94:
95: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
96:
97: //============
98: //= External =
99: //============
100:
101: IOService * IONDRVFramebuffer::probe( IOService * provider,
102: SInt32 * score )
103: {
104: IOService * inst = this;
105: IOService * newInst = 0;
106: const char * name;
107:
108: if( !super::probe( provider, score ))
109: return( 0 );
110:
111: if( IONDRV::fromRegistryEntry( provider )) {
112:
113: // temporary for in-kernel acceleration
114: name = provider->getName();
115: if( 0 == strncmp("ATY,Rage128", name, strlen("ATY,Rage128")))
116: newInst = new IOATI128NDRV;
117: else if( 0 == strncmp("ATY,", name, strlen("ATY,")))
118: newInst = new IOATINDRV;
119:
120: if( newInst) {
121: if( ! newInst->init( inst->getPropertyTable())) {
122: newInst->release();
123: newInst = 0;
124: }
125: inst = newInst;
126: }
127: } else
128: inst = 0;
129:
130: return( inst );
131: }
132:
133: bool IONDRVFramebuffer::start( IOService * provider )
134: {
135: bool ok = false;
136: IOService * parent;
137:
138: do {
139: nub = provider;
140: ndrv = IONDRV::fromRegistryEntry( provider );
141: if( 0 == ndrv)
142: continue;
143:
144: setName( ndrv->driverName());
145: startAt8 = 3;
146: consoleDevice = (0 != provider->getProperty("AAPL,boot-display"));
147:
148: if( 0 == nub->getDeviceMemoryCount()) {
149: parent = OSDynamicCast( IOService, nub->getParentEntry(gIODTPlane));
150: if( parent) {
151: parent->getResources();
152: OSArray * array = parent->getDeviceMemory();
153: array->retain();
154: nub->setDeviceMemory( array);
155: array->release();
156: }
157: }
158:
159: if( false == super::start( nub ))
160: continue;
161:
162: ok = true; // Success
163:
164: } while( false);
165:
166: return( ok);
167: }
168:
169: bool IONDRVFramebuffer::isConsoleDevice( void )
170: {
171: return( consoleDevice );
172: }
173:
174: // osfmk/ppc/mappings.h
175: extern "C" { extern void ignore_zero_fault(boolean_t); }
176:
177: IOReturn IONDRVFramebuffer::enableController( void )
178: {
179: IOReturn err;
180: const char * logname;
181:
182: logname = getProvider()->getName();
183:
184: if( 0 == strcmp( "control", logname))
185: waitForService( resourceMatching( "IOiic0" ));
186:
187: err = IONDRVLibrariesInitialize( getProvider() );
188:
189: if( kIOReturnSuccess == err) do {
190:
191: ignore_zero_fault( true );
192: err = checkDriver();
193: ignore_zero_fault( false );
194:
195: if( err) {
196: IOLog("%s: Not usable\n", logname );
197: if( err == -999)
198: IOLog("%s: driver incompatible.\n", logname );
199: continue;
200: }
201: getCurrentConfiguration();
202: vramMemory = findVRAM();
203:
204: } while( false);
205:
206: // initialize power management of the device
207: initForPM();
208:
209: return( err);
210: }
211:
212: IODeviceMemory * IONDRVFramebuffer::getVRAMRange( void )
213: {
214: if( vramMemory)
215: vramMemory->retain();
216:
217: return( vramMemory );
218: }
219:
220: void IONDRVFramebuffer::free( void )
221: {
222: super::free();
223: }
224:
225: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
226:
227: IOReturn IONDRVFramebuffer::registerForInterruptType( IOSelect interruptType,
228: IOFBInterruptProc proc, OSObject * target, void * ref,
229: void ** interruptRef )
230:
231: {
232: _VSLService * service;
233: IOReturn err;
234:
235: if( (interruptType == kIOFBVBLInterruptType)
236: && (getProvider()->getProperty("Ignore VBL")))
237: return( kIOReturnUnsupported );
238:
239: for( service = vslServices;
240: service && (service->type != interruptType);
241: service = service->next ) {}
242:
243: if( service) {
244:
245: if( service->handler)
246: err = kIOReturnBusy;
247:
248: else {
249: service->target = target;
250: service->ref = ref;
251: service->handler = proc;
252: *interruptRef = service;
253: err = kIOReturnSuccess;
254: }
255:
256: } else
257: err = kIOReturnNoResources;
258:
259: return( err );
260: }
261:
262: IOReturn IONDRVFramebuffer::unregisterInterrupt( void * interruptRef )
263: {
264: _VSLService * service = (_VSLService *) interruptRef;
265:
266: service->handler = 0;
267:
268: return( kIOReturnSuccess );
269: }
270:
271: IOReturn IONDRVFramebuffer::setInterruptState( void * interruptRef,
272: UInt32 state )
273: {
274: return( kIOReturnUnsupported );
275: }
276:
277: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
278:
279: //// VSL calls
280:
281: OSStatus IONDRVFramebuffer::VSLNewInterruptService(
282: void * entryID,
283: IOSelect serviceType,
284: _VSLService ** vslService )
285: {
286: IORegistryEntry * regEntry;
287: IONDRVFramebuffer * fb;
288: _VSLService * service;
289: IOReturn err = kIOReturnSuccess;
290:
291: REG_ENTRY_TO_OBJ( (const RegEntryID *) entryID, regEntry)
292:
293: fb = OSDynamicCast( IONDRVFramebuffer,
294: regEntry->getChildEntry( gIOServicePlane ));
295: assert( fb );
296:
297: if( fb) {
298: service = IONew( _VSLService, 1 );
299:
300: if( service) {
301: service->framebuffer = fb;
302: service->type = serviceType;
303: service->handler = 0;
304: service->next = fb->vslServices;
305: fb->vslServices = service;
306:
307: *vslService = service;
308:
309: } else
310: err = kIOReturnNoMemory;
311:
312: } else
313: err = kIOReturnBadArgument;
314:
315: return( err );
316: }
317:
318: OSStatus IONDRVFramebuffer::VSLDisposeInterruptService(_VSLService * vslService)
319: {
320: IONDRVFramebuffer * fb;
321: _VSLService * next;
322: _VSLService * prev;
323:
324: if( vslService) {
325:
326: fb = vslService->framebuffer;
327:
328: prev = fb->vslServices;
329: if( prev == vslService)
330: fb->vslServices = vslService->next;
331: else {
332: while( ((next = prev->next) != vslService) && next)
333: prev = next;
334: if( next)
335: prev->next = vslService->next;
336: }
337:
338: IODelete( vslService, _VSLService, 1 );
339: }
340:
341: return( kIOReturnSuccess );
342: }
343:
344: OSStatus IONDRVFramebuffer::VSLDoInterruptService( _VSLService * vslService )
345: {
346: IOFBInterruptProc proc;
347:
348: if( vslService) {
349: if( (proc = vslService->handler))
350: (*proc) (vslService->target, vslService->ref);
351: }
352:
353: return( kIOReturnSuccess );
354: }
355:
356: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
357:
358: struct _VSLCursorRef {
359: IOFramebuffer * framebuffer;
360: void * cursorImage;
361: };
362:
363: Boolean IONDRVFramebuffer::VSLPrepareCursorForHardwareCursor(
364: void * cursorRef,
365: IOHardwareCursorDescriptor * hwDesc,
366: IOHardwareCursorInfo * hwCursorInfo )
367: {
368: _VSLCursorRef * cursor = (_VSLCursorRef *) cursorRef;
369: bool ok;
370:
371: if( hwCursorInfo->colorMap)
372: hwCursorInfo->colorMap += 1;
373: ok = cursor->framebuffer->convertCursorImage(
374: cursor->cursorImage, hwDesc, hwCursorInfo );
375: if( hwCursorInfo->colorMap)
376: hwCursorInfo->colorMap -= 1;
377:
378: return( ok );
379: }
380:
381: IOReturn IONDRVFramebuffer::setCursorImage( void * cursorImage )
382: {
383: _VSLCursorRef cursorRef;
384: VDSetHardwareCursorRec setCursor;
385: IOReturn err;
386:
387: cursorRef.framebuffer = this;
388: cursorRef.cursorImage = cursorImage;
389:
390: setCursor.csCursorRef = (void *) &cursorRef;
391: setCursor.csReserved1 = 0;
392: setCursor.csReserved2 = 0;
393:
394: err = doControl( cscSetHardwareCursor, &setCursor );
395:
396: return( err );
397: }
398:
399: IOReturn IONDRVFramebuffer::setCursorState( SInt32 x, SInt32 y, bool visible )
400: {
401: VDDrawHardwareCursorRec drawCursor;
402: IOReturn err;
403:
404: if( 0 == OSIncrementAtomic( &ndrvEnter))
405: {
406:
407: drawCursor.csCursorX = x;
408: drawCursor.csCursorY = y;
409: drawCursor.csCursorVisible = visible;
410: drawCursor.csReserved1 = 0;
411: drawCursor.csReserved2 = 0;
412:
413: err = doControl( cscDrawHardwareCursor, &drawCursor );
414:
415: } else
416: err = kIOReturnBusy;
417:
418: OSDecrementAtomic( &ndrvEnter );
419:
420: return( err );
421: }
422:
423: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
424:
425: //============
426: //= Internal =
427: //============
428:
429: IOReturn IONDRVFramebuffer::doControl( UInt32 code, void * params )
430: {
431: IOReturn err;
432: CntrlParam pb;
433:
434: if( ndrvState == 0)
435: return( kIOReturnNotOpen);
436:
437: pb.qLink = 0;
438: pb.csCode = code;
439: pb.csParams = params;
440:
441: OSIncrementAtomic( &ndrvEnter );
442: err = ndrv->doDriverIO( /*ID*/ (UInt32) &pb, &pb,
443: kControlCommand, kImmediateIOCommandKind );
444: OSDecrementAtomic( &ndrvEnter );
445:
446: return( err);
447: }
448:
449: IOReturn IONDRVFramebuffer::doStatus( UInt32 code, void * params )
450: {
451: IOReturn err;
452: CntrlParam pb;
453:
454: if( ndrvState == 0)
455: return( kIOReturnNotOpen);
456:
457: pb.qLink = 0;
458: pb.csCode = code;
459: pb.csParams = params;
460:
461: OSIncrementAtomic( &ndrvEnter );
462: err = ndrv->doDriverIO( /*ID*/ (UInt32) &pb, &pb,
463: kStatusCommand, kImmediateIOCommandKind );
464: OSDecrementAtomic( &ndrvEnter );
465:
466: return( err);
467: }
468:
469:
470: IOReturn IONDRVFramebuffer::checkDriver( void )
471: {
472: OSStatus err = noErr;
473: struct DriverInitInfo initInfo;
474: CntrlParam pb;
475: VDClutBehavior clutSetting;
476: VDGammaRecord gammaRec;
477: VDSwitchInfoRec switchInfo;
478: IOTimingInformation info;
479: VDPageInfo pageInfo;
480:
481: if( ndrvState == 0) {
482: do {
483: initInfo.refNum = 0xffcd; // ...sure.
484: MAKE_REG_ENTRY(initInfo.deviceEntry, nub )
485:
486: err = ndrv->doDriverIO( 0, &initInfo,
487: kInitializeCommand, kImmediateIOCommandKind );
488: if( err) continue;
489:
490: err = ndrv->doDriverIO( 0, &pb,
491: kOpenCommand, kImmediateIOCommandKind );
492:
493: } while( false);
494:
495: if( err)
496: return( err);
497:
498: // allow calls to ndrv
499: ndrvState = 1;
500:
501: if( (noErr == doStatus( cscGetCurMode, &switchInfo ))
502: && (noErr == getTimingInfoForDisplayMode( switchInfo.csData, &info))
503: && (timingApple_0x0_0hz_Offline == info.appleTimingID)) {
504:
505: IOLog("%s: display offline\n", getName());
506: err = kIOReturnOffline;
507: return( err);
508: } else
509: ndrvState = 2;
510:
511: // duplicate QD InitGDevice
512: pageInfo.csMode = switchInfo.csMode;
513: pageInfo.csData = 0;
514: pageInfo.csPage = 0;
515: doControl( cscGrayPage, &pageInfo);
516:
517: clutSetting = kSetClutAtSetEntries;
518: lastClutSetting = clutSetting;
519: doControl( cscSetClutBehavior, &clutSetting);
520:
521: #if 1
522: // bogus for ROM control
523: do {
524:
525: VDGetGammaListRec scan;
526: VDRetrieveGammaRec get;
527: GammaTbl * table;
528: char name[ 64 ];
529:
530: scan.csPreviousGammaTableID = kGammaTableIDFindFirst;
531: scan.csGammaTableName = name;
532: err = doStatus( cscGetGammaInfoList, &scan);
533: if( err || (scan.csGammaTableID == kGammaTableIDNoMoreTables))
534: continue;
535:
536: table = (GammaTbl *)IOMalloc( scan.csGammaTableSize);
537: if( 0 == table)
538: continue;
539: get.csGammaTableID = scan.csGammaTableID;
540: get.csGammaTablePtr = table;
541:
542: err = doStatus( cscRetrieveGammaTable, &get );
543: if( noErr == err) {
544: kprintf("Setting gamma %s\n", scan.csGammaTableName);
545: gammaRec.csGTable = (Ptr) table;
546: doControl( cscSetGamma, &gammaRec );
547: }
548:
549: IOFree( table, scan.csGammaTableSize);
550:
551: } while( false);
552: #endif
553: }
554: return( noErr);
555: }
556:
557:
558: UInt32 IONDRVFramebuffer::iterateAllModes( IODisplayModeID * displayModeIDs )
559: {
560: VDResolutionInfoRec info;
561: UInt32 num = 0;
562:
563: info.csPreviousDisplayModeID = kDisplayModeIDFindFirstResolution;
564:
565: while(
566: (noErr == doStatus( cscGetNextResolution, &info))
567: && ((SInt32) info.csDisplayModeID > 0) ) {
568:
569: if( displayModeIDs)
570: displayModeIDs[ num ] = info.csDisplayModeID;
571:
572: info.csPreviousDisplayModeID = info.csDisplayModeID;
573: num++;
574: }
575: return( num);
576: }
577:
578:
579: IOReturn IONDRVFramebuffer::getResInfoForMode( IODisplayModeID modeID,
580: VDResolutionInfoRec ** theInfo )
581: {
582: // unfortunately, there is no "kDisplayModeIDFindSpecific"
583:
584: if( (SInt32) modeID <= 0)
585: return( kIOReturnUnsupportedMode);
586:
587: *theInfo = &cachedVDResolution;
588:
589: if( cachedVDResolution.csDisplayModeID == (UInt32) modeID)
590: return( noErr);
591:
592: // try the next after cached mode
593: cachedVDResolution.csPreviousDisplayModeID = cachedVDResolution.csDisplayModeID;
594:
595: if( (noErr == doStatus( cscGetNextResolution, &cachedVDResolution))
596: && (cachedVDResolution.csDisplayModeID == (UInt32) modeID) )
597: return( noErr);
598:
599: // full blown iterate
600: cachedVDResolution.csPreviousDisplayModeID = kDisplayModeIDFindFirstResolution;
601:
602: while(
603: (noErr == doStatus( cscGetNextResolution, &cachedVDResolution))
604: && (cachedVDResolution.csDisplayModeID != (UInt32) modeID)
605: && ((SInt32) cachedVDResolution.csDisplayModeID > 0)) {
606:
607: cachedVDResolution.csPreviousDisplayModeID = cachedVDResolution.csDisplayModeID;
608: }
609:
610: if( cachedVDResolution.csDisplayModeID == (UInt32) modeID)
611: return( noErr);
612:
613: cachedVDResolution.csDisplayModeID = 0xffffffff;
614: return( kIOReturnUnsupportedMode);
615: }
616:
617: void IONDRVFramebuffer::getCurrentConfiguration( void )
618: {
619: IOReturn err;
620: VDSwitchInfoRec switchInfo;
621: VDGrayRecord grayRec;
622:
623: grayRec.csMode = 0; // turn off luminance map
624: err = doControl( cscSetGray, &grayRec );
625: // driver refused => mono display
626: grayMode = ((noErr == err) && (0 != grayRec.csMode));
627:
628: err = doStatus( cscGetCurMode, &switchInfo );
629: if( err == noErr) {
630: currentDisplayMode = switchInfo.csData;
631: currentDepth = switchInfo.csMode - kDepthMode1;
632: currentPage = switchInfo.csPage;
633: if( 0 == (physicalFramebuffer = pmap_extract( kernel_pmap,
634: ((vm_address_t) switchInfo.csBaseAddr) )))
635: physicalFramebuffer = (UInt32) switchInfo.csBaseAddr;
636: } else
637: IOLog("%s: cscGetCurMode failed\n", nub->getName());
638: }
639:
640: IODeviceMemory * IONDRVFramebuffer::makeSubRange(
641: IOPhysicalAddress start,
642: IOPhysicalLength length )
643: {
644: IODeviceMemory * mem = 0;
645: UInt32 numMaps, i;
646: IOService * device;
647:
648: device = nub;
649: numMaps = device->getDeviceMemoryCount();
650:
651: for( i = 0; (!mem) && (i < numMaps); i++) {
652: mem = device->getDeviceMemoryWithIndex(i);
653: if( !mem)
654: continue;
655: mem = IODeviceMemory::withSubRange( mem,
656: start - mem->getPhysicalAddress(), length );
657: }
658: if( !mem)
659: mem = IODeviceMemory::withRange( start, length );
660:
661: return( mem );
662: }
663:
664: IODeviceMemory * IONDRVFramebuffer::getApertureRange( IOPixelAperture aper )
665: {
666: IOReturn err;
667: IOPixelInformation info;
668: IOByteCount bytes;
669:
670: err = getPixelInformation( currentDisplayMode, currentDepth, aper,
671: &info );
672: if( err)
673: return( 0 );
674:
675: bytes = (info.bytesPerRow * info.activeHeight) + 128;
676:
677: return( makeSubRange( physicalFramebuffer, bytes ));
678: }
679:
680: IODeviceMemory * IONDRVFramebuffer::findVRAM( void )
681: {
682: VDVideoParametersInfoRec pixelParams;
683: VPBlock pixelInfo;
684: VDResolutionInfoRec vdRes;
685: UInt32 size;
686: IOPhysicalAddress vramBase;
687: IOByteCount vramLength;
688: IOReturn err;
689:
690: vramLength = 0;
691: vdRes.csPreviousDisplayModeID = kDisplayModeIDFindFirstResolution;
692: while(
693: (noErr == doStatus( cscGetNextResolution, &vdRes))
694: && ((SInt32) vdRes.csDisplayModeID > 0) )
695: {
696: pixelParams.csDisplayModeID = vdRes.csDisplayModeID;
697: pixelParams.csDepthMode = vdRes.csMaxDepthMode;
698: pixelParams.csVPBlockPtr = &pixelInfo;
699: err = doStatus( cscGetVideoParameters, &pixelParams);
700: if( err)
701: continue;
702:
703: // Control hangs its framebuffer off the end of the aperture to support
704: // 832 x 624 @ 32bpp. The commented out version will correctly calculate
705: // the vram length, but DPS needs the full extent to be mapped, so we'll
706: // end up mapping an extra page that will address vram through the
707: // little endian aperture. No other drivers like this known.
708: #if 1
709: size = 0x40 + pixelInfo.vpBounds.bottom *
710: (pixelInfo.vpRowBytes & 0x7fff);
711: #else
712: size = ( (pixelInfo.vpBounds.right * pixelInfo.vpPixelSize) / 8) // last line
713: + (pixelInfo.vpBounds.bottom - 1) *
714: (pixelInfo.vpRowBytes & 0x7fff);
715: #endif
716: if( size > vramLength)
717: vramLength = size;
718:
719: vdRes.csPreviousDisplayModeID = vdRes.csDisplayModeID;
720: }
721:
722: vramBase = physicalFramebuffer;
723: vramLength = (vramLength + (vramBase & 0xffff) + 0xffff) & 0xffff0000;
724: vramBase &= 0xffff0000;
725:
726: return( makeSubRange( vramBase, vramLength ));
727: }
728:
729: //============
730: //= External =
731: //============
732:
733: const char * IONDRVFramebuffer::getPixelFormats( void )
734: {
735: static const char * ndrvPixelFormats =
736: IO1BitIndexedPixels "\0"
737: IO2BitIndexedPixels "\0"
738: IO4BitIndexedPixels "\0"
739: IO8BitIndexedPixels "\0"
740: IO16BitDirectPixels "\0"
741: IO32BitDirectPixels "\0"
742: "\0";
743:
744: return( ndrvPixelFormats);
745: }
746:
747: IOItemCount IONDRVFramebuffer::getDisplayModeCount( void )
748: {
749: return( iterateAllModes( 0 ));
750: }
751:
752: IOReturn IONDRVFramebuffer::getDisplayModes( IODisplayModeID * allDisplayModes )
753: {
754: iterateAllModes( allDisplayModes );
755: return( kIOReturnSuccess );
756: }
757:
758: IOReturn IONDRVFramebuffer::getInformationForDisplayMode(
759: IODisplayModeID displayMode, IODisplayModeInformation * info )
760: {
761: IOReturn err;
762: VDResolutionInfoRec * resInfo;
763:
764: bzero( info, sizeof( *info));
765: do {
766: err = getResInfoForMode( displayMode, &resInfo );
767: if( err)
768: continue;
769: info->maxDepthIndex = resInfo->csMaxDepthMode - kDepthMode1;
770: info->nominalWidth = resInfo->csHorizontalPixels;
771: info->nominalHeight = resInfo->csVerticalLines;
772: info->refreshRate = resInfo->csRefreshRate;
773: return( noErr);
774: } while( false);
775:
776: return( kIOReturnUnsupportedMode);
777: }
778:
779:
780: UInt64 IONDRVFramebuffer::getPixelFormatsForDisplayMode(
781: IODisplayModeID /* displayMode */, IOIndex depthIndex )
782: {
783: return( 1 << (depthIndex + startAt8));
784: }
785:
786: IOReturn IONDRVFramebuffer::getPixelInformation(
787: IODisplayModeID displayMode, IOIndex depth,
788: IOPixelAperture aperture, IOPixelInformation * info )
789: {
790: SInt32 err;
791: VDVideoParametersInfoRec pixelParams;
792: VPBlock pixelInfo;
793: const char * formats;
794: UInt32 mask;
795: int index;
796:
797: bzero( info, sizeof( *info));
798:
799: if( aperture)
800: return( kIOReturnUnsupportedMode);
801:
802: do {
803: pixelParams.csDisplayModeID = displayMode;
804: pixelParams.csDepthMode = depth + kDepthMode1;
805: pixelParams.csVPBlockPtr = &pixelInfo;
806: err = doStatus( cscGetVideoParameters, &pixelParams );
807: if( err)
808: continue;
809:
810: //info->flags = kFramebufferSupportsCopybackCache;
811:
812: info->activeWidth = pixelInfo.vpBounds.right;
813: info->activeHeight = pixelInfo.vpBounds.bottom;
814: info->bytesPerRow = pixelInfo.vpRowBytes & 0x7fff;
815: info->bytesPerPlane = pixelInfo.vpPlaneBytes;
816: info->bitsPerPixel = pixelInfo.vpPixelSize;
817:
818: formats = getPixelFormats();
819: mask = getPixelFormatsForDisplayMode( displayMode, depth );
820:
821: for( index = 0; index < 32; index++) {
822: if( (mask & (1 << index)) && ((aperture--) == 0)) {
823: strcpy( info->pixelFormat, formats);
824: break;
825: }
826: formats += strlen( formats) + 1;
827: }
828:
829: if( 0 == strcmp("PPPPPPPP", info->pixelFormat)) {
830: info->pixelType = kIOCLUTPixels;
831: info->componentMasks[0] = 0xff;
832: info->bitsPerPixel = 8;
833: info->componentCount = 1;
834: info->bitsPerComponent = 8;
835:
836: } else if( 0 == strcmp("-RRRRRGGGGGBBBBB", info->pixelFormat)) {
837: info->pixelType = kIORGBDirectPixels;
838: info->componentMasks[0] = 0x7c00;
839: info->componentMasks[1] = 0x03e0;
840: info->componentMasks[2] = 0x001f;
841: info->bitsPerPixel = 16;
842: info->componentCount = 3;
843: info->bitsPerComponent = 5;
844:
845: } else if( 0 == strcmp("--------RRRRRRRRGGGGGGGGBBBBBBBB",
846: info->pixelFormat)) {
847: info->pixelType = kIORGBDirectPixels;
848: info->componentMasks[0] = 0x00ff0000;
849: info->componentMasks[1] = 0x0000ff00;
850: info->componentMasks[2] = 0x000000ff;
851: info->bitsPerPixel = 32;
852: info->componentCount = 3;
853: info->bitsPerComponent = 8;
854: }
855:
856: } while( false);
857:
858: return( err);
859: }
860:
861: IOReturn IONDRVFramebuffer::getTimingInfoForDisplayMode(
862: IODisplayModeID displayMode, IOTimingInformation * info )
863: {
864: VDTimingInfoRec timingInfo;
865: OSStatus err;
866:
867: timingInfo.csTimingMode = displayMode;
868: // in case the driver doesn't do it:
869: timingInfo.csTimingFormat = kDeclROMtables;
870: err = doStatus( cscGetModeTiming, &timingInfo);
871: if( err == noErr) {
872: if( timingInfo.csTimingFormat == kDeclROMtables)
873: info->appleTimingID = timingInfo.csTimingData;
874: else
875: info->appleTimingID = timingInvalid;
876:
877: return( kIOReturnSuccess);
878: }
879:
880: return( kIOReturnUnsupportedMode);
881: }
882:
883: IOReturn IONDRVFramebuffer::getCurrentDisplayMode(
884: IODisplayModeID * displayMode, IOIndex * depth )
885: {
886: if( displayMode)
887: *displayMode = currentDisplayMode;
888: if( depth)
889: *depth = currentDepth;
890:
891: return( kIOReturnSuccess);
892: }
893:
894: IOReturn IONDRVFramebuffer::setDisplayMode( IODisplayModeID displayMode, IOIndex depth )
895: {
896: SInt32 err;
897: VDSwitchInfoRec switchInfo;
898: VDPageInfo pageInfo;
899:
900: switchInfo.csData = displayMode;
901: switchInfo.csMode = depth + kDepthMode1;
902: switchInfo.csPage = 0;
903: err = doControl( cscSwitchMode, &switchInfo);
904: if(err)
905: IOLog("%s: cscSwitchMode:%d\n", nub->getName(), (int)err);
906:
907: // duplicate QD InitGDevice
908: pageInfo.csMode = switchInfo.csMode;
909: pageInfo.csData = 0;
910: pageInfo.csPage = 0;
911: doControl( cscSetMode, &pageInfo);
912: doControl( cscGrayPage, &pageInfo);
913:
914: getCurrentConfiguration();
915:
916: return( err);
917: }
918:
919: IOReturn IONDRVFramebuffer::setStartupDisplayMode(
920: IODisplayModeID displayMode, IOIndex depth )
921: {
922: SInt32 err;
923: VDSwitchInfoRec switchInfo;
924:
925: switchInfo.csData = displayMode;
926: switchInfo.csMode = depth + kDepthMode1;
927: err = doControl( cscSavePreferredConfiguration, &switchInfo);
928: return( err);
929: }
930:
931: IOReturn IONDRVFramebuffer::getStartupDisplayMode(
932: IODisplayModeID * displayMode, IOIndex * depth )
933: {
934: SInt32 err;
935: VDSwitchInfoRec switchInfo;
936:
937: err = doStatus( cscGetPreferredConfiguration, &switchInfo);
938: if( err == noErr) {
939: *displayMode = switchInfo.csData;
940: *depth = switchInfo.csMode - kDepthMode1;
941: }
942: return( err);
943: }
944:
945: IOReturn IONDRVFramebuffer::setApertureEnable( IOPixelAperture /* aperture */,
946: IOOptionBits /* enable */ )
947: {
948: return( kIOReturnSuccess);
949: }
950:
951: IOReturn IONDRVFramebuffer::setCLUTWithEntries(
952: IOColorEntry * colors, UInt32 index, UInt32 numEntries,
953: IOOptionBits options )
954: {
955: IOReturn err;
956: UInt32 code;
957: VDSetEntryRecord setEntryRec;
958: VDClutBehavior clutSetting;
959: VDGrayRecord grayRec;
960:
961: if( options & kSetCLUTWithLuminance)
962: grayRec.csMode = 1; // turn on luminance map
963: else
964: grayRec.csMode = 0; // turn off luminance map
965:
966: if( grayRec.csMode != lastGrayMode) {
967: doControl( cscSetGray, &grayRec);
968: lastGrayMode = grayRec.csMode;
969: }
970:
971: if( options & kSetCLUTImmediately)
972: clutSetting = kSetClutAtSetEntries;
973: else
974: clutSetting = kSetClutAtVBL;
975:
976: if( clutSetting != lastClutSetting) {
977: doControl( cscSetClutBehavior, &clutSetting);
978: lastClutSetting = clutSetting;
979: }
980:
981: if( options & kSetCLUTByValue)
982: setEntryRec.csStart = -1;
983: else
984: setEntryRec.csStart = index;
985:
986: setEntryRec.csTable = (ColorSpec *) colors;
987: setEntryRec.csCount = numEntries - 1;
988: if( directMode)
989: code = cscDirectSetEntries;
990: else
991: code = cscSetEntries;
992: err = doControl( code, &setEntryRec);
993:
994: return( err);
995: }
996:
997: IOReturn IONDRVFramebuffer::setGammaTable( UInt32 channelCount, UInt32 dataCount,
998: UInt32 dataWidth, void * data )
999: {
1000: IOReturn err;
1001: VDGammaRecord gammaRec;
1002: struct GammaTbl {
1003: short gVersion; /*gamma version number*/
1004: short gType; /*gamma data type*/
1005: short gFormulaSize; /*Formula data size*/
1006: short gChanCnt; /*number of channels of data*/
1007: short gDataCnt; /*number of values/channel*/
1008: short gDataWidth; /*bits/corrected value */
1009: /* (data packed to next larger byte size)*/
1010: UInt8 gFormulaData[0]; /*data for formulas followed by gamma values*/
1011: };
1012: GammaTbl * table = NULL;
1013: IOByteCount dataLen = 0;
1014:
1015: if( data) {
1016: dataLen = (dataWidth + 7) / 8;
1017: dataLen *= dataCount * channelCount;
1018: table = (GammaTbl *) IOMalloc( dataLen + sizeof( struct GammaTbl));
1019: if( NULL == table)
1020: return( kIOReturnNoMemory);
1021:
1022: table->gVersion = 0;
1023: table->gType = 0;
1024: table->gFormulaSize = 0;
1025: table->gChanCnt = channelCount;
1026: table-> gDataCnt = dataCount;
1027: table->gDataWidth = dataWidth;
1028: bcopy( data, table->gFormulaData, dataLen);
1029: }
1030:
1031: gammaRec.csGTable = (Ptr) table;
1032: err = doControl( cscSetGamma, &gammaRec);
1033: if( table)
1034: IOFree( table, dataLen + sizeof( struct GammaTbl));
1035:
1036: return( err);
1037: }
1038:
1039: IOReturn IONDRVFramebuffer::getAttribute( IOSelect attribute, UInt32 * value )
1040: {
1041: IOReturn err = kIOReturnSuccess;
1042: VDSupportsHardwareCursorRec hwCrsrSupport;
1043:
1044: switch( attribute ) {
1045:
1046: case kIOHardwareCursorAttribute:
1047:
1048: *value = ((kIOReturnSuccess ==
1049: doStatus( cscSupportsHardwareCursor, &hwCrsrSupport))
1050: && (hwCrsrSupport.csSupportsHardwareCursor));
1051: break;
1052:
1053: default:
1054: err = super::getAttribute( attribute, value );
1055: }
1056:
1057: return( err );
1058: }
1059:
1060: UInt32 IONDRVFramebuffer::getConnectionCount( void )
1061: {
1062: VDMultiConnectInfoRec theRecord;
1063:
1064: if( doStatus(cscGetMultiConnect,&theRecord) == 0 ) {
1065: return theRecord.csDisplayCountOrNumber;
1066: }
1067: return 1;
1068: }
1069:
1070: IOReturn IONDRVFramebuffer::setAttributeForConnection( IOIndex connectIndex,
1071: IOSelect attribute, UInt32 info )
1072: {
1073: IOReturn ret;
1074: VDSyncInfoRec theVDSyncInfoRec;
1075:
1076: switch( attribute ) {
1077:
1078: case kConnectionSyncEnable:
1079: theVDSyncInfoRec.csMode = (unsigned char)(info>>8);
1080: theVDSyncInfoRec.csFlags = (unsigned char)(info & 0xFF);
1081: doControl(cscSetSync,&theVDSyncInfoRec);
1082: ret = kIOReturnSuccess;
1083: break;
1084: default:
1085: ret = super::setAttributeForConnection( connectIndex,
1086: attribute, info );
1087: break;
1088: }
1089: return( ret );
1090: }
1091:
1092:
1093: IOReturn IONDRVFramebuffer::getAttributeForConnection( IOIndex connectIndex,
1094: IOSelect attribute, UInt32 * value )
1095: {
1096: IOReturn ret;
1097: VDSyncInfoRec theVDSyncInfoRec;
1098:
1099: switch( attribute ) {
1100:
1101: case kConnectionSyncFlags:
1102: // find out current state of sync lines
1103: theVDSyncInfoRec.csMode = 0x00;
1104: doStatus(cscGetSync,&theVDSyncInfoRec);
1105: * value = theVDSyncInfoRec.csMode;
1106: ret = kIOReturnSuccess;
1107: break;
1108: case kConnectionSyncEnable:
1109: // what are the sync-controlling capabilities of the ndrv?
1110: theVDSyncInfoRec.csMode = 0xFF;
1111: doStatus(cscGetSync,&theVDSyncInfoRec);
1112: * value = (UInt32)theVDSyncInfoRec.csMode;
1113: ret = kIOReturnSuccess;
1114: break;
1115: case kConnectionSupportsHLDDCSense:
1116: case kConnectionSupportsAppleSense:
1117: ret = kIOReturnSuccess;
1118: break;
1119: default:
1120: ret = super::getAttributeForConnection( connectIndex,
1121: attribute, value );
1122: break;
1123: }
1124:
1125: return( ret );
1126: }
1127:
1128: IOReturn IONDRVFramebuffer::getAppleSense( IOIndex connectIndex,
1129: UInt32 * senseType,
1130: UInt32 * primary,
1131: UInt32 * extended,
1132: UInt32 * displayType )
1133: {
1134: OSStatus err;
1135: VDMultiConnectInfoRec multiConnect;
1136: UInt32 sense, extSense;
1137:
1138: if( connectIndex == 0 )
1139: err = doStatus( cscGetConnection, &multiConnect.csConnectInfo);
1140:
1141: else {
1142: multiConnect.csDisplayCountOrNumber = connectIndex;
1143: err = doControl( cscSetMultiConnect, &multiConnect);
1144: }
1145: if( err)
1146: return( err);
1147:
1148: if( multiConnect.csConnectInfo.csConnectFlags
1149: & ((1<<kReportsTagging) | (1<<kTaggingInfoNonStandard))
1150: != ((1<<kReportsTagging)) )
1151:
1152: err = kIOReturnUnsupported;
1153:
1154: else {
1155:
1156: sense = multiConnect.csConnectInfo.csConnectTaggedType;
1157: extSense = multiConnect.csConnectInfo.csConnectTaggedData;
1158: // bug fixes for really old ATI driver
1159: if( sense == 0) {
1160: if( extSense == 6) {
1161: sense = kRSCSix;
1162: extSense = kESCSixStandard;
1163: }
1164: else
1165: if( extSense == 4) {
1166: sense = kRSCFour;
1167: extSense = kESCFourNTSC;
1168: }
1169: }
1170: if( primary)
1171: *primary = sense;
1172: if( extended)
1173: *extended = extSense;
1174: if( displayType)
1175: *displayType = multiConnect.csConnectInfo.csDisplayType;
1176: if( senseType)
1177: *senseType = 0;
1178: }
1179: return( err);
1180: }
1181:
1182: IOReturn IONDRVFramebuffer::connectFlags( IOIndex /* connectIndex */,
1183: IODisplayModeID displayMode, IOOptionBits * flags )
1184: {
1185: VDTimingInfoRec timingInfo;
1186: OSStatus err;
1187:
1188: timingInfo.csTimingMode = displayMode;
1189: // in case the driver doesn't do it:
1190: timingInfo.csTimingFormat = kDeclROMtables;
1191: err = doStatus( cscGetModeTiming, &timingInfo);
1192: *flags = timingInfo.csTimingFlags;
1193: return( err );
1194: }
1195:
1196:
1197: bool IONDRVFramebuffer::hasDDCConnect( IOIndex connectIndex )
1198: {
1199: OSStatus err;
1200: VDMultiConnectInfoRec multiConnect;
1201: enum { kNeedFlags = (1<<kReportsDDCConnection)
1202: | (1<<kHasDDCConnection) };
1203: if( connectIndex == 0 )
1204: err = doStatus( cscGetConnection, &multiConnect.csConnectInfo);
1205: else {
1206: multiConnect.csDisplayCountOrNumber = connectIndex;
1207: err = doControl( cscSetMultiConnect, &multiConnect);
1208: }
1209: if( err)
1210: return( err);
1211:
1212: return( (multiConnect.csConnectInfo.csConnectFlags & kNeedFlags)
1213: == kNeedFlags );
1214: }
1215:
1216: IOReturn IONDRVFramebuffer::getDDCBlock( IOIndex /* connectIndex */,
1217: UInt32 blockNumber,
1218: IOSelect blockType,
1219: IOOptionBits options,
1220: UInt8 * data, IOByteCount * length )
1221:
1222: {
1223: OSStatus err = 0;
1224: VDDDCBlockRec ddcRec;
1225: ByteCount actualLength = *length;
1226:
1227: ddcRec.ddcBlockNumber = blockNumber;
1228: ddcRec.ddcBlockType = blockType;
1229: ddcRec.ddcFlags = options;
1230:
1231: err = doStatus( cscGetDDCBlock, &ddcRec);
1232:
1233: if( err == noErr) {
1234:
1235: if( actualLength < kDDCBlockSize)
1236: actualLength = actualLength;
1237: else
1238: actualLength = kDDCBlockSize;
1239: bcopy( ddcRec.ddcBlockData, data, actualLength);
1240: *length = actualLength;
1241: }
1242: return( err);
1243: }
1244:
1245: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1246: // initForPM
1247: //
1248: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1249: void IONDRVFramebuffer::initForPM ( void )
1250: {
1251: // register ourselves with superclass policy-maker
1252: registerControllingDriver(this,ourPowerStates,number_of_power_states);
1253: }
1254:
1255:
1256: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1257: // maxCapabilityForDomainState
1258: //
1259: // This simple device needs only power. If the power domain is supplying
1260: // power, the frame buffer can be on. If there is no power it can only be off.
1261: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1262:
1263: unsigned long IONDRVFramebuffer::maxCapabilityForDomainState(
1264: IOPMPowerFlags domainState )
1265: {
1266: if( domainState & IOPMPowerOn )
1267: return number_of_power_states-1;
1268: else
1269: return 0;
1270: }
1271:
1272:
1273: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1274: // initialPowerStateForDomainState
1275: //
1276: // The power domain may be changing state. If power is on in the new
1277: // state, that will not affect our state at all. If domain power is off,
1278: // we can attain only our lowest state, which is off.
1279: //
1280: // This implementation is incomplete. It only works in a system where
1281: // the frame buffer is never turned off. When we cross that bridge,
1282: // instead of returning 1, it should return 1 if the frame buffer
1283: // is on, or 0 if it is off.
1284: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1285: unsigned long IONDRVFramebuffer::initialPowerStateForDomainState(
1286: IOPMPowerFlags domainState )
1287: {
1288: if( domainState & IOPMPowerOn )
1289: return number_of_power_states-1;
1290: else
1291: return 0;
1292: }
1293:
1294:
1295: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1296: // powerStateForDomainState
1297: //
1298: // The power domain may be changing state. If power is on in the new
1299: // state, that will not affect our state at all. If domain power is off,
1300: // we can attain only our lowest state, which is off.
1301: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1302: unsigned long IONDRVFramebuffer::powerStateForDomainState(
1303: IOPMPowerFlags domainState )
1304: {
1305: if( domainState & IOPMPowerOn )
1306: return pm_vars->myCurrentState;
1307: else
1308: return 0;
1309: }
1310:
1311:
1312: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1313: // setPowerState
1314: //
1315: // Called by the superclass to turn the frame buffer on and off.
1316: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1317: IOReturn IONDRVFramebuffer::setPowerState( unsigned long powerStateOrdinal,
1318: IOService* whatDevice )
1319: {
1320: if ( powerStateOrdinal == 0 ) {
1321: kprintf("frame buffer would be powered off here\n");
1322: }
1323: if ( powerStateOrdinal == 1 ) {
1324: kprintf("frame buffer would be powered on here\n");
1325: }
1326: return IOPMAckImplied;
1327: }
1328:
1329: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1330:
1331: // ATI patches.
1332: // Real problem : getStartupMode doesn't.
1333:
1334: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1335:
1336: #undef super
1337: #define super IONDRVFramebuffer
1338:
1339: OSDefineMetaClassAndStructors(IOATINDRV, IONDRVFramebuffer)
1340: OSDefineMetaClassAndStructors(IOATI128NDRV, IOATINDRV)
1341:
1342: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1343:
1344: IOReturn IOATINDRV::getStartupDisplayMode(
1345: IODisplayModeID * displayMode, IOIndex * depth )
1346: {
1347: UInt16 * nvram;
1348: OSData * prop;
1349:
1350: prop = OSDynamicCast( OSData, nub->getProperty("Sime"));
1351: if( prop) {
1352: nvram = (UInt16 *) prop->getBytesNoCopy();
1353: *displayMode = nvram[ 0 ]; // 1 is physDisplayMode
1354: *depth = nvram[ 2 ] - kDepthMode1;
1355: return( kIOReturnSuccess);
1356: } else
1357: return(super::getStartupDisplayMode( displayMode, depth));
1358: }
1359:
1360: IODeviceMemory * IOATINDRV::findVRAM( void )
1361: {
1362: OSData * prop;
1363: IOPhysicalAddress vramBase;
1364: IOByteCount vramLength;
1365:
1366: prop = OSDynamicCast( OSData, nub->getProperty("APPL,VRAMSize"));
1367: if( !prop)
1368: prop = OSDynamicCast( OSData, nub->getProperty("ATY,memsize"));
1369: if( !prop)
1370: return( super::findVRAM());
1371:
1372: vramBase = physicalFramebuffer;
1373: vramLength = *((IOByteCount *)prop->getBytesNoCopy());
1374: if( !vramLength)
1375: return( super::findVRAM());
1376: vramLength = (vramLength + (vramBase & 0xffff)) & 0xffff0000;
1377: vramBase &= 0xffff0000;
1378:
1379: return( makeSubRange( vramBase, vramLength ));
1380: }
1381:
1382: static int g128ExtraCurs = 8;
1383: static int g128DeltaCurs = 0x25c0;
1384:
1385: void IOATI128NDRV::flushCursor( void )
1386: {
1387: volatile UInt32 * fb;
1388: UInt32 x;
1389: int i;
1390:
1391: fb = (volatile UInt32 *) frameBuffer;
1392: for( i = 0; i < g128ExtraCurs; i++) {
1393: x += *(fb++);
1394: fb += g128DeltaCurs;
1395: }
1396: }
1397:
1398:
1399:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.