![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AppleG3SeriesDisplay.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOGraphics|
Return to AppleG3SeriesDisplay.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOGraphics |
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: #include <IOKit/IOLib.h>
24: #include <IOKit/graphics/IODisplay.h>
25: #include <IOKit/ndrvsupport/IOMacOSVideo.h>
26:
27: #include <Drivers/platform/drvApplePMU/pmupriv.h>
28: #include <Drivers/hidsystem/drvAppleADBDevices/AppleADBButtons.h>
29:
30: #define kNumber_of_power_states 4
31: #define kNumber_of_power_levels 32
32:
33: #define kScreenBit 0x01
34: #define kPowerOn 0x80
35: #define kPowerOff 0x00
36: #define kDisplayOn kScreenBit | kPowerOn
37: #define kDisplayOff kScreenBit | kPowerOff
38:
39: class ApplePMU;
40:
41:
42: class AppleG3SeriesDisplay : public AppleSenseDisplay
43: {
44: OSDeclareDefaultStructors(AppleG3SeriesDisplay)
45:
46: private:
47:
48: int current_user_brightness; // 0-31. The brightness level last selected via the brightness buttons.
49: int current_level; // 0-31. The current brightness level
50: ApplePMU * PMUdriver; // points to PMU driver
51: int * rawTable; // points to table of raw brightess levels
52:
53: public:
54: IOService * probe ( IOService *, SInt32 * );
55: virtual void initForPM ( IOService* );
56: virtual IOReturn setPowerState ( unsigned long, IOService* );
57: virtual unsigned long maxCapabilityForDomainState ( IOPMPowerFlags );
58: virtual unsigned long initialPowerStateForDomainState ( IOPMPowerFlags );
59: virtual unsigned long powerStateForDomainState ( IOPMPowerFlags );
60: virtual void ourButtonHandler ( unsigned int );
61: virtual void setBrightness ( long );
62: };
63:
64: void upButtonHandler(AppleG3SeriesDisplay *);
65: void downButtonHandler(AppleG3SeriesDisplay *);
66:
67:
68: /*
69: The actual display panel has 128 power levels. Copying the MacOS, we only implement 32 of them.
70: We further divide the 32 into four IOKit power states which we export to our superclass.
71:
72: In the lowest state, the display is off. This state consists of only one of the 32 power levels, the lowest.
73: In the next state it is in the dimmest usable state. This state also consists of only one of the 32 levels, the second lowest.
74: The next state is also dim and consists of seven of the 32 levels.
75: The highest state consists of the highest 23 levels.
76:
77: The display has no state or configuration or programming that would be saved/restored over power state changes,
78: and the driver does not register with the superclass as an interested driver.
79:
80: This driver doesn't have much to do. It changes between the four power state brightnesses on command
81: from the superclass, and it raises and lowers the display brightness by one of the 32 brightness levels
82: when it receives a brightness-button interrupt from the ADB stack.
83:
84: The only smart thing it does is keep track of which of the 32 brightness levels the user has selected by button, and it
85: never exceeds that on command from the display device object. It only raises above that on an brightness-up-button
86: interrupt.
87:
88: */
89:
90:
91: static IOPMPowerState ourPowerStates[kNumber_of_power_states] = {
92: {1,0,0,0,0,0,0,0,0,0,0,0},
93: {1,IOPMDeviceUsable,0,IOPMPowerOn,0,0,0,0,0,0,0,0},
94: {1,IOPMDeviceUsable,0,IOPMPowerOn,0,0,0,0,0,0,0,0},
95: {1,IOPMDeviceUsable+IOPMMaxPerformance,0,IOPMPowerOn,0,0,0,0,0,0,0,0}
96: };
97:
98: static int max_brightness_level[kNumber_of_power_states] = {0,1,8,31};
99:
100: static int HooperTable[ ] = {127,71,69,67,65,63,61,59,
101: 58,56,54,52,50,48,46,44,
102: 42,40,38,37,35,33,31,29,
103: 27,25,23,21,19,18,16,14 };
104:
105: bool ourNotificationHandler( OSObject *, void *, IOService * );
106:
107: #define super AppleSenseDisplay
108:
109: OSDefineMetaClassAndStructors(AppleG3SeriesDisplay, AppleSenseDisplay)
110:
111:
112: // **********************************************************************************
113: // probe
114: //
115: // **********************************************************************************
116: IOService * AppleG3SeriesDisplay::probe ( IOService * provider, SInt32 * score )
117: {
118: IOFramebuffer * framebuffer;
119: IOService * ret = 0;
120: UInt32 displayType;
121: IOIndex ourIndex;
122:
123: do {
124: if ( 0 == super::probe( provider, score ) ) {
125: continue;
126: }
127:
128: framebuffer = (IOFramebuffer *)getConnection()->getFramebuffer(); // point to our framebuffer
129: ourIndex = getConnection()->getConnection(); // get our connection index on this framebuffer
130:
131: if ( kIOReturnSuccess != framebuffer->getAppleSense(ourIndex,NULL,NULL,NULL,&displayType) ) {
132: continue;
133: }
134:
135: if ( !(displayType == kPanelTFTConnect) ) { // does it have a panel attached?
136: continue; // no
137: }
138: ret = this; // yes, we will control the panel
139:
140: } while ( false );
141:
142: return ( ret );
143: }
144:
145:
146: // **********************************************************************************
147: // initForPM
148: //
149: // This method overrides the one in IODisplay.h to do PowerBook-only
150: // power management of the display.
151: // **********************************************************************************
152: void AppleG3SeriesDisplay::initForPM ( IOService * provider )
153: {
154: IOByteCount unused;
155: const OSSymbol * PMUname;
156: IOService * service;
157: unsigned long i;
158: UInt8 PMUreceiveBuffer[10]; // (I think 1 is enough, but it scares me)
159:
160:
161: displayPMVars->powerControllable = true;
162:
163: PMinit(); // initialize superclass variables
164:
165: PMUname = OSSymbol::withCStringNoCopy(kPMUname); // find the PMU driver
166: service = waitForService(resourceMatching(PMUname));
167: PMUdriver = OSDynamicCast(ApplePMU, service->getProperty(PMUname));
168:
169: rawTable = HooperTable;
170:
171: PMUdriver->sendMiscCommand(kPMUpower1Read,0, NULL, &unused,PMUreceiveBuffer);
172: if ( PMUreceiveBuffer[0] & kScreenBit ) { // is the screen currently on?
173: PMUdriver->sendMiscCommand(kPMUReadBrightness,0, NULL, &unused,PMUreceiveBuffer); // yes, figure out the brightness
174: current_user_brightness = kNumber_of_power_levels - 1; // ( in case the for-loop doesn't break)
175: current_level = kNumber_of_power_levels - 1;
176:
177: for ( i = 0; i < kNumber_of_power_levels; i++ ) {
178: if ( PMUreceiveBuffer[0] >= rawTable[i] ) {
179: current_user_brightness = i;
180: current_level = i;
181: break;
182: }
183: }
184: }
185: else { // no
186: current_user_brightness = 0;
187: current_level = 0;
188: }
189:
190: addNotification( gIOPublishNotification,serviceMatching("AppleADBButtons"), // look for the button driver
191: (IOServiceNotificationHandler)ourNotificationHandler, this, 0 );
192:
193: provider->joinPMtree(this); // attach into the power management hierarchy
194: registerControllingDriver(this,ourPowerStates,kNumber_of_power_states); // register with policy-maker (us)
195: }
196:
197:
198: // **********************************************************************************
199: // ourNotificationHandler
200: //
201: // The ADB button driver has appeared. Tell it we are interested in the
202: // brightness-up button and the brightness-down button.
203: // **********************************************************************************
204: bool ourNotificationHandler( OSObject * us, void * ref, IOService * yourDevice )
205: {
206: if ( yourDevice != NULL ) {
207: ((AppleADBButtons *)yourDevice)->registerForButton(kBrightness_up,(IOService *)us,(button_handler)upButtonHandler,true);
208: ((AppleADBButtons *)yourDevice)->registerForButton(kBrightness_down,(IOService *)us,(button_handler)downButtonHandler,true);
209: }
210: return true;
211: }
212:
213:
214: // **********************************************************************************
215: // setPowerState
216: //
217: // All power state changes require a call to the PMU driver, which
218: // blocks the thread till the command completes.
219: // **********************************************************************************
220: IOReturn AppleG3SeriesDisplay::setPowerState ( unsigned long powerStateOrdinal, IOService* whatDevice )
221: {
222: UInt8 displayOn = kDisplayOn;
223: UInt8 displayOff = kDisplayOff;
224: IOByteCount unused;
225: unsigned long i;
226:
227: if ( powerStateOrdinal < kNumber_of_power_states ) {
228: if ( powerStateOrdinal > pm_vars->myCurrentState ) { // raising power
229: if ( pm_vars->myCurrentState == 0 ) { // is it currently off?
230: PMUdriver->sendMiscCommand(kPMUpower1Cntl,1, &displayOn, &unused,NULL);
231: }
232: current_level = max_brightness_level[powerStateOrdinal];
233: if ( current_user_brightness < current_level ) {
234: current_level = current_user_brightness; // don't exceed what the user used to have it at
235: }
236: setBrightness(current_level);
237: // If we are still higher than we need to be, request a lower state
238: for ( i = 0; i < kNumber_of_power_states; i++ ) { // figure out what state we should be in
239: if ( current_level <= max_brightness_level[i] ) {
240: break;
241: }
242: }
243: if ( pm_vars->myCurrentState > i ) {
244: changeStateToPriv(i);
245: }
246: }
247:
248: if ( powerStateOrdinal < pm_vars->myCurrentState ) { // lowering power
249: if (powerStateOrdinal == 0 ) { // going all the way off?
250: PMUdriver->sendMiscCommand(kPMUpower1Cntl,1, &displayOff, &unused,NULL); // yes
251: current_level = max_brightness_level[powerStateOrdinal];
252: }
253: else {
254: if ( current_level > max_brightness_level[powerStateOrdinal] ) { // no
255: current_level = max_brightness_level[powerStateOrdinal];
256: setBrightness(current_level);
257: }
258: }
259: }
260: }
261: return IOPMAckImplied;
262: }
263:
264:
265: // **********************************************************************************
266: // maxCapabilityForDomainState
267: //
268: // This simple device needs only power. If the power domain is supplying
269: // power, the display can go to its highest state. If there is no power
270: // it can only be in its lowest state, which is off.
271: // **********************************************************************************
272: unsigned long AppleG3SeriesDisplay::maxCapabilityForDomainState ( IOPMPowerFlags domainState )
273: {
274: if ( domainState & IOPMPowerOn ) {
275: return kNumber_of_power_states-1;
276: }
277: return 0;
278: }
279:
280:
281: // **********************************************************************************
282: // initialPowerStateForDomainState
283: //
284: // The power domain may be changing state. If power is on in the new
285: // state, that will not affect our state at all. If domain power is off,
286: // we can attain only our lowest state, which is off.
287: // **********************************************************************************
288: unsigned long AppleG3SeriesDisplay::initialPowerStateForDomainState ( IOPMPowerFlags domainState )
289: {
290: long unsigned i;
291:
292: if ( domainState & IOPMPowerOn ) { // domain has power
293: for ( i = 0; i < kNumber_of_power_states; i++ ) { // find power state that has our current
294: if ( current_level <= max_brightness_level[i] ) { // brightness level
295: return i;
296: break;
297: }
298: }
299: }
300: return 0; // domain is down, so display is off
301: }
302:
303:
304: // **********************************************************************************
305: // powerStateForDomainState
306: //
307: // The power domain may be changing state. If power is on in the new
308: // state, that will not affect our state at all. If domain power is off,
309: // we can attain only our lowest state, which is off.
310: // **********************************************************************************
311: unsigned long AppleG3SeriesDisplay::powerStateForDomainState ( IOPMPowerFlags domainState )
312: {
313: long unsigned i;
314:
315: if ( domainState & IOPMPowerOn ) { // domain has power
316: for ( i = 0; i < kNumber_of_power_states; i++ ) { // find power state that has our current
317: if ( current_level <= max_brightness_level[i] ) { // brightness level
318: return i;
319: }
320: }
321: }
322: return 0; // domain is down, so display is off
323: }
324:
325:
326: // **********************************************************************************
327: // upButtonHandler
328: //
329: // The display-brightness-up button just went down.
330: // We are running on a new thread made by the ADB Button driver
331: // **********************************************************************************
332: void upButtonHandler(AppleG3SeriesDisplay * us )
333: {
334: ((AppleG3SeriesDisplay *)us)->ourButtonHandler(kBrightness_up);
335: }
336:
337:
338: // **********************************************************************************
339: // downButtonHandler
340: //
341: // The display-brightness-down button just went down.
342: // We are running on a new thread made by the ADB Button driver
343: // **********************************************************************************
344: void downButtonHandler(AppleG3SeriesDisplay * us )
345: {
346: ((AppleG3SeriesDisplay *)us)->ourButtonHandler(kBrightness_down);
347: }
348:
349:
350: // **********************************************************************************
351: // ourButtonHandler
352: //
353: // Alter the backlight brightness up or down by one increment.
354: // This involves a call to the PMU driver, which will block the thread.
355: // **********************************************************************************
356: void AppleG3SeriesDisplay::ourButtonHandler ( unsigned int keycode )
357: { // If we are idle, ignore the button.
358: // The display will be made usable
359: if ( ! displayPMVars->displayIdle ) { // by the DisplayWrangler
360: switch (keycode) {
361: case kBrightness_up: // The brightness-up button has just been pressed
362: // We make sure the brightness is not above the maximum
363: // brightness level of our current power state. If it
364: // is too high, we ask the device to raise power.
365: if (current_level < max_brightness_level[pm_vars->myCurrentState] ) {
366: current_level++;
367: current_user_brightness = current_level;
368: setBrightness(current_level);
369: }
370: else {
371: if ( pm_vars->myCurrentState < (kNumber_of_power_states-1) ) {
372: current_user_brightness++; // increment user's desire
373: if ( changeStateToPriv(pm_vars->myCurrentState + 1) != IOPMNoErr ) { // request higher power
374: current_user_brightness--; // can't
375: }
376: }
377: }
378: break;
379:
380: case kBrightness_down: // The brightness-down button has just been pressed
381: // We lower the brightness, and if that takes us into a
382: // lower power state, we tell our parent about it.
383: if ( pm_vars->myCurrentState > 0 ) { // don't lower if in lowest (off) state
384: if ( current_level > 0 ) {
385: current_level--;
386: current_user_brightness = current_level;
387: setBrightness(current_level);
388: if (current_level <= max_brightness_level[pm_vars->myCurrentState - 1] ) { // if this takes us into the next lower state
389: changeStateToPriv(pm_vars->myCurrentState - 1); // request lower power
390: }
391: }
392: }
393: break;
394: }
395: }
396: }
397:
398:
399: // **********************************************************************************
400: // setBrightness
401: //
402: // Instruct PMU to set the display brightness.
403: // This will block the thread while the command completes.
404: // **********************************************************************************
405: void AppleG3SeriesDisplay::setBrightness ( long brightness )
406: {
407: IOByteCount unused;
408: UInt8 setBrightnessBuffer;
409:
410: setBrightnessBuffer = (UInt8)rawTable[brightness];
411: PMUdriver->sendMiscCommand(kPMUSetBrightness,1, &setBrightnessBuffer, &unused,NULL);
412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.