| /* |
| * Copyright 2014 Intel Corporation All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.intel.thermal; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlPullParserFactory; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.os.SystemProperties; |
| import android.util.Log; |
| |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Hashtable; |
| |
| /** |
| * The ThermalCooling class parses the thermal_throttle_config.xml. This class |
| * receives Thermal Intents and takes appropriate actions based on the policies |
| * configured in the xml file. |
| * |
| * @hide |
| */ |
| public class ThermalCooling { |
| private static final String TAG = "ThermalCooling"; |
| private static final String THERMAL_SHUTDOWN_NOTIFY_PATH = |
| "/sys/module/intel_mid_osip/parameters/force_shutdown_occured"; |
| |
| private Context mContext; |
| |
| // count to keep track of zones in critical state, waiting for shutdown |
| private int mCriticalZonesCount = 0; |
| private static final Object sCriticalZonesCountLock = new Object(); |
| |
| private ThermalZoneReceiver mThermalIntentReceiver = new ThermalZoneReceiver(); |
| private ProfileChangeReceiver mProfChangeReceiver = new ProfileChangeReceiver(); |
| private boolean mProfChangeListenerInitialized = false; |
| /** |
| * This is the parser class which parses the thermal_throttle_config.xml |
| * file. |
| */ |
| protected enum MetaTag { |
| ENUM_THROTTLEVALUES, |
| ENUM_THROTTLEMASK, |
| ENUM_DETHROTTLEMASK, |
| ENUM_UNKNOWN |
| } |
| |
| public class ThermalParser { |
| private static final String THERMAL_THROTTLE_CONFIG = "thermalthrottleconfig"; |
| |
| private static final String CDEVINFO = "ContributingDeviceInfo"; |
| |
| private static final String ZONETHROTINFO = "ZoneThrottleInfo"; |
| |
| private static final String COOLINGDEVICEINFO = "CoolingDeviceInfo"; |
| |
| private static final String THROTTLEMASK = "ThrottleDeviceMask"; |
| |
| private static final String DETHROTTLEMASK = "DethrottleDeviceMask"; |
| |
| private static final String THROTTLEVALUES = "ThrottleValues"; |
| |
| private static final String COOLINGDEVICESTATES = "CoolingDeviceStates"; |
| |
| private static final String PROFILE = "Profile"; |
| |
| private ArrayList<Integer> mTempMaskList; |
| |
| private ArrayList<Integer> mTempThrottleValuesList;; |
| |
| private boolean done = false; |
| |
| XmlPullParserFactory mFactory; |
| |
| XmlPullParser mParser; |
| |
| ThermalCoolingDevice mDevice = null; |
| |
| /* Hashtable of (ZoneID and ZoneCoolerBindingInfo object) */ |
| Hashtable<Integer, ThermalManager.ZoneCoolerBindingInfo> mZoneCoolerBindMap = null; |
| String mCurProfileName = ThermalManager.DEFAULT_PROFILE_NAME; |
| int mNumProfiles = 0; |
| |
| ThermalManager.ZoneCoolerBindingInfo mZone = null; |
| |
| FileReader mInputStream = null; |
| |
| ThermalParser(String fname) { |
| try { |
| mFactory = XmlPullParserFactory.newInstance( |
| System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null); |
| mFactory.setNamespaceAware(true); |
| mParser = mFactory.newPullParser(); |
| } catch (XmlPullParserException xppe) { |
| Log.e(TAG, "mParser NewInstance Exception"); |
| } |
| |
| try { |
| mInputStream = new FileReader(fname); |
| if (mInputStream == null) |
| return; |
| if (mParser != null) { |
| mParser.setInput(mInputStream); |
| } |
| mDevice = null; |
| mZone = null; |
| } catch (XmlPullParserException xppe) { |
| Log.e(TAG, "mParser setInput XmlPullParserException"); |
| } catch (FileNotFoundException e) { |
| Log.e(TAG, "mParser setInput FileNotFoundException"); |
| } |
| |
| } |
| |
| ThermalParser() { |
| mParser = mContext.getResources(). |
| getXml(ThermalManager.sThrottleFileXmlId); |
| } |
| |
| public boolean parse() { |
| if (ThermalManager.sIsOverlays == false && mInputStream == null) return false; |
| /* if mParser is null, close any open stream before exiting */ |
| if (mParser == null) { |
| try { |
| if (mInputStream != null) { |
| mInputStream.close(); |
| } |
| } catch (IOException e) { |
| Log.i(TAG, "IOException caught in parse() function"); |
| } |
| return false; |
| } |
| |
| boolean ret = true; |
| MetaTag tag = MetaTag.ENUM_UNKNOWN; |
| try { |
| int mEventType = mParser.getEventType(); |
| while (mEventType != XmlPullParser.END_DOCUMENT && !done) { |
| switch (mEventType) { |
| case XmlPullParser.START_DOCUMENT: |
| Log.i(TAG, "StartDocument"); |
| break; |
| case XmlPullParser.START_TAG: |
| String tagName = mParser.getName(); |
| boolean isMetaTag = false; |
| if (tagName != null && tagName.equalsIgnoreCase(THROTTLEVALUES)) { |
| tag = MetaTag.ENUM_THROTTLEVALUES; |
| isMetaTag = true; |
| } else if (tagName != null && tagName.equalsIgnoreCase(THROTTLEMASK)) { |
| tag = MetaTag.ENUM_THROTTLEMASK; |
| isMetaTag = true; |
| } else if (tagName != null |
| && tagName.equalsIgnoreCase(DETHROTTLEMASK)) { |
| tag = MetaTag.ENUM_DETHROTTLEMASK; |
| isMetaTag = true; |
| } |
| if (isMetaTag) { |
| ret = processMetaTag(tagName, tag); |
| } else { |
| ret = processStartElement(tagName); |
| } |
| if (!ret) { |
| if (mInputStream != null) mInputStream.close(); |
| return false; |
| } |
| break; |
| case XmlPullParser.END_TAG: |
| processEndElement(mParser.getName()); |
| break; |
| } |
| mEventType = mParser.next(); |
| } |
| } catch (XmlPullParserException xppe) { |
| Log.i(TAG, "XmlPullParserException caught in parse():" + xppe.getMessage()); |
| ret = false; |
| } catch (IOException e) { |
| Log.i(TAG, "IOException caught in parse():" + e.getMessage()); |
| ret = false; |
| } finally { |
| try { |
| // end of parsing, close the stream |
| // close is moved here, since if there is an exception |
| // while parsing doc, input stream needs to be closed |
| if (mInputStream != null) { |
| mInputStream.close(); |
| } |
| } catch (IOException e) { |
| Log.i(TAG, "IOException caught in parse() function"); |
| ret = false; |
| } |
| return ret; |
| } |
| } |
| |
| public boolean processMetaTag(String tagName, MetaTag tagId) { |
| if (mParser == null || tagName == null) return false; |
| ArrayList<Integer> tempList = new ArrayList<Integer>(); |
| try { |
| int eventType = mParser.next(); |
| while (true) { |
| if (eventType == XmlPullParser.START_TAG) { |
| tempList.add(Integer.parseInt(mParser.nextText())); |
| } else if (eventType == XmlPullParser.END_TAG && |
| mParser.getName().equalsIgnoreCase(tagName)) { |
| break; |
| } |
| eventType = mParser.next(); |
| } |
| } catch (XmlPullParserException xppe) { |
| Log.e(TAG, "XmlPullParserException:" + xppe.getMessage()); |
| return false; |
| } catch (IOException ioe) { |
| Log.e(TAG, "IOException:" + ioe.getMessage()); |
| return false; |
| } |
| |
| switch(tagId) { |
| case ENUM_THROTTLEVALUES: |
| if (mDevice == null) { |
| return false; |
| } else { |
| // add throttle value for TCRITICAL (same as last value) |
| tempList.add(tempList.get(tempList.size() - 1)); |
| mDevice.setThrottleValuesList(tempList); |
| } |
| break; |
| case ENUM_THROTTLEMASK: |
| if (mZone == null || mZone.getLastCoolingDeviceInstance() == null) { |
| return false; |
| } else { |
| // Always throttle at CRITICAL state (last state) |
| tempList.add(1); |
| mZone.getLastCoolingDeviceInstance().setThrottleMaskList(tempList); |
| } |
| break; |
| case ENUM_DETHROTTLEMASK: |
| if (mZone == null || mZone.getLastCoolingDeviceInstance() == null) { |
| return false; |
| } else { |
| // Dethrottling at CRITICAL state (last state) is dontcare condition |
| tempList.add(0); |
| mZone.getLastCoolingDeviceInstance().setDeThrottleMaskList(tempList); |
| } |
| break; |
| default: |
| return false; |
| } |
| return true; |
| } |
| boolean processStartElement(String name) { |
| if (name == null) |
| return false; |
| boolean ret = true; |
| try { |
| if (name.equalsIgnoreCase(CDEVINFO)) { |
| if (mDevice == null) |
| mDevice = new ThermalCoolingDevice(); |
| } else if (name.equalsIgnoreCase(ZONETHROTINFO)) { |
| if (mZone == null) { |
| mZone = new ThermalManager.ZoneCoolerBindingInfo(); |
| } |
| if (mZoneCoolerBindMap == null) { |
| mZoneCoolerBindMap = new Hashtable<Integer, |
| ThermalManager.ZoneCoolerBindingInfo>(); |
| } |
| } else if (name.equalsIgnoreCase(PROFILE)) { |
| mNumProfiles++; |
| if (mZoneCoolerBindMap == null) { |
| mZoneCoolerBindMap = new Hashtable<Integer, |
| ThermalManager.ZoneCoolerBindingInfo>(); |
| } |
| } else if (name.equalsIgnoreCase(COOLINGDEVICEINFO) && mZone != null) { |
| if (mZone.getCoolingDeviceInfoList() == null) { |
| mZone.initializeCoolingDeviceInfoList(); |
| } |
| mZone.createNewCoolingDeviceInstance(); |
| } else { |
| // Retrieve zone and cooling device mapping |
| if (name.equalsIgnoreCase("ZoneID") && mZone != null) { |
| mZone.setZoneID(Integer.parseInt(mParser.nextText())); |
| } else if (name.equalsIgnoreCase("CriticalShutDown") && mZone != null) { |
| mZone.setCriticalActionShutdown(Integer.parseInt(mParser.nextText())); |
| } else if (name.equalsIgnoreCase(THROTTLEMASK) && mZone != null) { |
| mTempMaskList = new ArrayList<Integer>(); |
| } else if (name.equalsIgnoreCase(DETHROTTLEMASK) && mZone != null) { |
| mTempMaskList = new ArrayList<Integer>(); |
| } else if (name.equalsIgnoreCase("CoolingDevId") && mZone != null) { |
| mZone.getLastCoolingDeviceInstance().setCoolingDeviceId( |
| Integer.parseInt(mParser.nextText())); |
| } else if (name.equalsIgnoreCase(COOLINGDEVICESTATES) && mZone != null) { |
| // Increase cooling device states by 1, required for CRITICAL state |
| mZone.getLastCoolingDeviceInstance().setCoolingDeviceStates( |
| Integer.parseInt(mParser.nextText()) + 1); |
| } |
| // Retrieve cooling device information |
| if (name.equalsIgnoreCase("CDeviceName") && mDevice != null) { |
| mDevice.setDeviceName(mParser.nextText()); |
| } else if (name.equalsIgnoreCase("CDeviceID") && mDevice != null) { |
| mDevice.setDeviceId(Integer.parseInt(mParser.nextText())); |
| } else if (name.equalsIgnoreCase("CDeviceClassPath") && mDevice != null) { |
| mDevice.setClassPath(mParser.nextText()); |
| } else if (name.equalsIgnoreCase("CDeviceThrottlePath") && mDevice != null) { |
| mDevice.setThrottlePath(mParser.nextText()); |
| } else if (name.equalsIgnoreCase("Name")) { |
| mCurProfileName = mParser.nextText(); |
| } |
| } |
| } catch (XmlPullParserException e) { |
| Log.i(TAG, "XmlPullParserException caught in processStartElement()"); |
| ret = false; |
| } catch (IOException e) { |
| Log.i(TAG, "IOException caught in processStartElement()"); |
| ret = false; |
| } finally { |
| return ret; |
| } |
| } |
| |
| void processEndElement(String name) { |
| if (name == null) |
| return; |
| if (name.equalsIgnoreCase(CDEVINFO) && mDevice != null) { |
| // if cooling dev suports less then DEFAULT throttle values donot add to map. |
| if (mDevice.getNumThrottleValues() < ThermalManager.DEFAULT_NUM_THROTTLE_VALUES) { |
| Log.i(TAG, "cooling dev:" + mDevice.getDeviceName() |
| + " deactivated! throttle values < " |
| + ThermalManager.DEFAULT_NUM_THROTTLE_VALUES); |
| mDevice = null; |
| return; |
| } |
| if (mDevice.getThrottlePath().equals("auto")) { |
| mDevice.setThrottlePath("auto"); |
| } |
| if (loadCoolingDevice(mDevice)) { |
| ThermalManager.sCDevMap.put(mDevice.getDeviceId(), mDevice); |
| } |
| mDevice = null; |
| } else if (name.equalsIgnoreCase(ZONETHROTINFO) && mZone != null) { |
| mZone.printAttributes(); |
| if (mZoneCoolerBindMap != null) { |
| mZoneCoolerBindMap.put(mZone.getZoneID(), mZone); |
| } |
| mZone = null; |
| } else if (name.equalsIgnoreCase(PROFILE)) { |
| if (mZoneCoolerBindMap != null) { |
| ThermalManager.sProfileBindMap.put(mCurProfileName, mZoneCoolerBindMap); |
| mZoneCoolerBindMap = new Hashtable<Integer, |
| ThermalManager.ZoneCoolerBindingInfo>(); |
| } |
| } else if (name.equalsIgnoreCase(THERMAL_THROTTLE_CONFIG)) { |
| Log.i(TAG, "Parsing Finished.."); |
| // This indicates we have not seen any <Profile> tag. |
| // Consider it as if we have only one 'Default' Profile. |
| if (mNumProfiles == 0 && mZoneCoolerBindMap != null) { |
| ThermalManager.sProfileBindMap.put(mCurProfileName, mZoneCoolerBindMap); |
| } |
| done = true; |
| } else if (name.equalsIgnoreCase(COOLINGDEVICEINFO) && mZone != null) { |
| ThermalManager.ZoneCoolerBindingInfo.CoolingDeviceInfo cDevInfo; |
| cDevInfo = mZone.getLastCoolingDeviceInstance(); |
| if (cDevInfo != null) { |
| ThermalCoolingDevice cDev = ThermalManager.sCDevMap |
| .get(cDevInfo.getCoolingDeviceId()); |
| if (cDev == null) return; |
| int cds = cDevInfo.getCoolingDeviceStates(); |
| // check the CDS against the number of throttle values exposed. |
| // If exceeds, cap it. |
| if (cds > cDev.getNumThrottleValues()) { |
| cDevInfo.setCoolingDeviceStates(cDev.getNumThrottleValues()); |
| Log.i(TAG, "capping cdevid: " + cDevInfo.getCoolingDeviceId() |
| + " to " + cDev.getNumThrottleValues() + " states"); |
| } |
| if (cDevInfo.checkMaskList(cDev.getNumThrottleValues())) { |
| // add only active cooling devices to list |
| mZone.addCoolingDeviceToList(cDevInfo); |
| } |
| } |
| } |
| } |
| } |
| |
| private void configureDynamicTurbo() { |
| // Disable Dynamic Turbo based on the system property |
| int indx = ThermalUtils.getCoolingDeviceIndexContains("SoC"); |
| if (indx != -1 && !ThermalManager.sIsDynamicTurboEnabled) { |
| String path = ThermalManager.sCoolingDeviceBasePath + indx |
| + ThermalManager.sCoolingDeviceState; |
| ThermalUtils.writeSysfs(path, ThermalManager.DISABLE_DYNAMIC_TURBO); |
| } |
| } |
| |
| public boolean init(Context context) { |
| Log.i(TAG, "Thermal Cooling manager init() called"); |
| |
| mContext = context; |
| ThermalParser parser; |
| if (!ThermalManager.sIsOverlays) { |
| parser = new ThermalParser(ThermalManager.sThrottleFilePath); |
| } else { |
| parser = new ThermalParser(); |
| } |
| |
| if (parser == null || !parser.parse()) { |
| Log.i(TAG, "thermal_throttle_config.xml parsing failed"); |
| return false; |
| } |
| |
| // Set this sZoneCoolerBindMap to the DefaultProfile Map |
| ThermalManager.setCurBindMap(ThermalManager.DEFAULT_PROFILE_NAME); |
| |
| // Register for thermal zone state changed notifications |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(ThermalManager.ACTION_THERMAL_ZONE_STATE_CHANGED); |
| mContext.registerReceiver(mThermalIntentReceiver, filter); |
| |
| configureDynamicTurbo(); |
| return true; |
| } |
| |
| private final class ProfileChangeReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(ThermalManager.ACTION_CHANGE_THERMAL_PROFILE)) { |
| String profName = intent.getStringExtra(ThermalManager.EXTRA_PROFILE); |
| if (profName != null) { |
| ThermalManager.changeThermalProfile(profName); |
| } |
| } |
| } |
| } |
| |
| private void incrementCrticalZoneCount() { |
| synchronized(sCriticalZonesCountLock) { |
| mCriticalZonesCount++; |
| } |
| } |
| |
| private final class ThermalZoneReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String zoneName = intent.getStringExtra(ThermalManager.EXTRA_NAME); |
| String profName = intent.getStringExtra(ThermalManager.EXTRA_PROFILE); |
| int thermZone = intent.getIntExtra(ThermalManager.EXTRA_ZONE, -1); |
| int thermState = intent.getIntExtra(ThermalManager.EXTRA_STATE, 0); |
| int thermEvent = intent.getIntExtra(ThermalManager.EXTRA_EVENT, 0); |
| int zoneTemp = intent.getIntExtra(ThermalManager.EXTRA_TEMP, 0); |
| |
| // Assume 'Default' profile if there is no profile parameter |
| // as part of the intent. |
| if (profName == null) { |
| profName = ThermalManager.DEFAULT_PROFILE_NAME; |
| } |
| |
| Log.i(TAG, "Received THERMAL INTENT:(ProfileName, ZoneName, State, EventType, Temp):" |
| + "(" + profName + ", " + zoneName + ", " + thermState + ", " |
| + ThermalZone.getEventTypeAsString(thermEvent) + ", " + zoneTemp + ")"); |
| |
| Hashtable<Integer, ThermalManager.ZoneCoolerBindingInfo> mBindMap = |
| ThermalManager.getBindMap(profName); |
| if (mBindMap == null) { |
| Log.i(TAG, "mBindMap null inside ThermalZoneReceiver"); |
| return; |
| } |
| |
| ThermalManager.ZoneCoolerBindingInfo zoneCoolerBindInfo = mBindMap.get(thermZone); |
| if (zoneCoolerBindInfo == null) { |
| Log.i(TAG, "zoneCoolerBindInfo null for zoneID" + thermZone); |
| return; |
| } |
| |
| boolean flag = zoneCoolerBindInfo.getCriticalActionShutdown() == 1; |
| int lastState = zoneCoolerBindInfo.getLastState(); |
| if (thermState < lastState) { |
| ThermalManager.updateZoneCriticalPendingMap(thermZone, |
| ThermalManager.CRITICAL_FALSE); |
| } else if (thermState == lastState && flag) { |
| /* no telephony support, so (!isEmergencyCallOnGoing) is true */ |
| if (true) { |
| doShutdown(); |
| } else { |
| // increment the count of zones in critical state pending on shutdown |
| ThermalManager.updateZoneCriticalPendingMap(thermZone, |
| ThermalManager.CRITICAL_TRUE); |
| } |
| } |
| |
| /* if THERMALOFF is the zone state, it is guaranteed that the zone has transitioned |
| from a higher state, due to a low event, to THERMALOFF.Hence take de-throttling action |
| corresponding to NORMAL */ |
| if (thermState == ThermalManager.THERMAL_STATE_OFF) { |
| thermState = ThermalManager.THERMAL_STATE_NORMAL; |
| } |
| handleThermalEvent(thermZone, thermEvent, thermState, zoneCoolerBindInfo); |
| } |
| } |
| |
| private boolean loadCoolingDevice(ThermalCoolingDevice device) { |
| Class cls; |
| Method throttleMethod; |
| String classPath = device.getClassPath(); |
| |
| if (classPath == null) { |
| Log.i(TAG, "ClassPath not found"); |
| return false; |
| } |
| |
| if (classPath.equalsIgnoreCase("none") || classPath.equalsIgnoreCase("auto") |
| || classPath.equalsIgnoreCase("AppAgent")) { |
| Log.i(TAG, "ClassPath: none/auto/AppAgent"); |
| return true; |
| } |
| |
| /* Load the cooling device class */ |
| try { |
| cls = Class.forName(classPath); |
| device.setDeviceClass(cls); |
| } catch (Throwable e) { |
| Log.i(TAG, "Unable to load class " + classPath); |
| return false; |
| } |
| |
| /* Initialize the cooling device class */ |
| try { |
| Class partypes[] = new Class[3]; |
| partypes[0] = Context.class; |
| partypes[1] = String.class; |
| partypes[2] = ArrayList.class; |
| Method init = cls.getMethod("init", partypes); |
| Object arglist[] = new Object[3]; |
| arglist[0] = mContext; |
| arglist[1] = device.getThrottlePath(); |
| arglist[2] = device.getThrottleValuesList(); |
| init.invoke(cls, arglist); |
| } catch (NoSuchMethodException e) { |
| Log.i(TAG, "NoSuchMethodException caught in device class init: " + classPath); |
| } catch (SecurityException e) { |
| Log.i(TAG, "SecurityException caught in device class init: " + classPath); |
| } catch (IllegalAccessException e) { |
| Log.i(TAG, "IllegalAccessException caught in device class init: " + classPath); |
| } catch (IllegalArgumentException e) { |
| Log.i(TAG, "IllegalArgumentException caught in device class init: " + classPath); |
| } catch (ExceptionInInitializerError e) { |
| Log.i(TAG, "ExceptionInInitializerError caught in device class init: " + classPath); |
| } catch (InvocationTargetException e) { |
| Log.i(TAG, "InvocationTargetException caught in device class init: " + classPath); |
| } |
| |
| /* Get the throttleDevice method from cooling device class */ |
| try { |
| Class partypes[] = new Class[1]; |
| partypes[0] = Integer.TYPE; |
| throttleMethod = cls.getMethod("throttleDevice", partypes); |
| device.setThrottleMethod(throttleMethod); |
| } catch (NoSuchMethodException e) { |
| Log.i(TAG, "NoSuchMethodException caught initializing throttle function"); |
| } catch (SecurityException e) { |
| Log.i(TAG, "SecurityException caught initializing throttle function"); |
| } |
| |
| return true; |
| } |
| |
| |
| public void doShutdown() { |
| ThermalUtils.writeSysfs(THERMAL_SHUTDOWN_NOTIFY_PATH, 1); |
| /* We must avoid reboot after shutdown. */ |
| SystemProperties.set("sys.property_forcedshutdown", "1"); |
| Intent criticalIntent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN); |
| criticalIntent.putExtra(Intent.EXTRA_KEY_CONFIRM, false); |
| criticalIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| Log.i(TAG, "Thermal Service initiating shutdown"); |
| mContext.startActivity(criticalIntent); |
| } |
| |
| public void registerProfChangeListener() { |
| IntentFilter profChangeIntentFilter = new IntentFilter(); |
| profChangeIntentFilter.addAction(ThermalManager.ACTION_CHANGE_THERMAL_PROFILE); |
| // TODO: add some permission (BRICK ??) to protect it from third party apps |
| mContext.registerReceiver(mProfChangeReceiver, profChangeIntentFilter); |
| mProfChangeListenerInitialized = true; |
| } |
| |
| /* Method to handle the thermal event based on HIGH or LOW event */ |
| private void handleThermalEvent(int zoneId, int eventType, int thermalState, |
| ThermalManager.ZoneCoolerBindingInfo zoneCoolerBindInfo) { |
| ThermalCoolingDevice tDevice; |
| int deviceId; |
| int existingState, targetState; |
| int currThrottleMask, currDethrottleMask; |
| int index = 0; |
| |
| if (zoneCoolerBindInfo.getCoolingDeviceInfoList() == null) |
| return; |
| |
| for (ThermalManager.ZoneCoolerBindingInfo.CoolingDeviceInfo CdeviceInfo : |
| zoneCoolerBindInfo.getCoolingDeviceInfoList()) { |
| int coolingDeviceState = thermalState / |
| zoneCoolerBindInfo.getZoneToCoolDevBucketSizeIndex(index); |
| // cap it |
| coolingDeviceState = (coolingDeviceState > (CdeviceInfo.getCoolingDeviceStates() - 1)) |
| ? CdeviceInfo.getCoolingDeviceStates() - 1 : coolingDeviceState; |
| int finalThrottleState = coolingDeviceState * |
| zoneCoolerBindInfo.getCoolDevToThrottBucketSizeIndex(index); |
| // cap it |
| finalThrottleState = (finalThrottleState > (CdeviceInfo.getMaxThrottleStates() - 1)) |
| ? CdeviceInfo.getMaxThrottleStates() - 1 : finalThrottleState; |
| index++; |
| if (ThermalManager.THERMAL_HIGH_EVENT == eventType) { |
| ArrayList<Integer> throttleMaskList = CdeviceInfo.getThrottleMaskList(); |
| if (throttleMaskList == null) continue; |
| // cap to avoid out of bound exception |
| coolingDeviceState = (coolingDeviceState > throttleMaskList.size() - 1) |
| ? throttleMaskList.size() - 1 : coolingDeviceState; |
| currThrottleMask = throttleMaskList.get(coolingDeviceState); |
| deviceId = CdeviceInfo.getCoolingDeviceId(); |
| |
| tDevice = ThermalManager.sCDevMap.get(deviceId); |
| if (tDevice == null) |
| continue; |
| |
| if (currThrottleMask == ThermalManager.THROTTLE_MASK_ENABLE) { |
| existingState = tDevice.getThermalState(); |
| tDevice.updateZoneState(zoneId, finalThrottleState); |
| targetState = tDevice.getThermalState(); |
| |
| /* Do not throttle if device is already in desired state. |
| * (We can save Sysfs write) |
| * */ |
| if (existingState != targetState) throttleDevice(deviceId, targetState); |
| |
| } else { |
| // If throttle mask is not enabled, don't do anything here. |
| } |
| } |
| |
| if (ThermalManager.THERMAL_LOW_EVENT == eventType) { |
| ArrayList<Integer> dethrottleMaskList = CdeviceInfo.getDeThrottleMaskList(); |
| if (dethrottleMaskList == null) continue; |
| // cap to avoid out of bound exception |
| coolingDeviceState = (coolingDeviceState > dethrottleMaskList.size() - 1) |
| ? dethrottleMaskList.size() - 1 : coolingDeviceState; |
| currDethrottleMask = dethrottleMaskList.get(coolingDeviceState); |
| deviceId = CdeviceInfo.getCoolingDeviceId(); |
| |
| tDevice = ThermalManager.sCDevMap.get(deviceId); |
| if (tDevice == null) |
| continue; |
| |
| existingState = tDevice.getThermalState(); |
| tDevice.updateZoneState(zoneId, finalThrottleState); |
| targetState = tDevice.getThermalState(); |
| |
| /* Do not dethrottle if device is already in desired state. |
| * (We can save Sysfs write) */ |
| if ((existingState != targetState) && |
| (currDethrottleMask == ThermalManager.DETHROTTLE_MASK_ENABLE)) { |
| throttleDevice(deviceId, targetState); |
| } |
| } |
| } |
| |
| } |
| |
| /* |
| * defaultThrottleMethod is called for cooling devices for which an additional |
| * plugin file is not provided. Since the throttle path and the throttle values |
| * are known, we dont need an additional plugin to implement the policy. This info |
| * is provided via thermal_throttle_config file. If for a cooling device, |
| * Assumptions - |
| * 1. If CDeviceClassPath is 'auto' this triggers a call to defaultThrottleMethod(). |
| * if a false throttle path is provided, the write fails and function exits gracefully |
| * with a warning message. |
| * 2. If 'auto' mode is used for CDeviceClassPath, and no throttle values are provided, |
| * thermal state will be written. |
| * 3. If CDeviceThrottlePath is 'auto', then throttle path will be constrcuted. |
| * The Cooling device name should contain a subset string that matches the type for |
| * /sys/class/thermal/cooling_deviceX/type inorder to find the right index X |
| * 4. CDeviceThrottlePath is null no write operation will be done |
| **/ |
| private void defaultThrottleMethod(ThermalCoolingDevice cdev, int level) { |
| int finalValue; |
| String throttlePath = null; |
| |
| if (cdev == null) return; |
| |
| if (level < cdev.getNumThrottleValues() - 1) { |
| try { |
| ArrayList<Integer> values = cdev.getThrottleValuesList(); |
| if (values == null || values.size() == 0) { |
| finalValue = level; |
| } else { |
| finalValue = values.get(level); |
| } |
| |
| throttlePath = cdev.getThrottlePath(); |
| if (throttlePath == null) { |
| Log.w(TAG, "throttle path is null"); |
| return; |
| } |
| |
| if (!ThermalUtils.isFileExists(throttlePath)) { |
| Log.w(TAG, "invalid throttle path for cooling device:" + cdev.getDeviceName()); |
| return; |
| } |
| |
| if (ThermalUtils.writeSysfs(throttlePath, finalValue) == -1) { |
| Log.w(TAG, "write to sysfs failed"); |
| } |
| } catch (IndexOutOfBoundsException e) { |
| Log.w(TAG, "IndexOutOfBoundsException caught in defaultThrottleMethod()"); |
| } |
| } |
| } |
| |
| /* Method to throttle cooling device */ |
| private void throttleDevice(int coolingDevId, int throttleLevel) { |
| /* Retrieve the cooling device based on ID */ |
| ThermalCoolingDevice dev = ThermalManager.sCDevMap.get(coolingDevId); |
| if (dev != null) { |
| if (dev.getClassPath() != null && dev.getClassPath().equalsIgnoreCase("auto")) { |
| defaultThrottleMethod(dev, throttleLevel); |
| } else { |
| Class c = dev.getDeviceClass(); |
| Method throt = dev.getThrottleMethod(); |
| if (throt == null) |
| return; |
| Object arglist[] = new Object[1]; |
| arglist[0] = new Integer(throttleLevel); |
| |
| // Invoke the throttle method passing the throttle level as parameter |
| try { |
| throt.invoke(c, arglist); |
| } catch (IllegalAccessException e) { |
| Log.i(TAG, "IllegalAccessException caught throttleDevice() "); |
| } catch (IllegalArgumentException e) { |
| Log.i(TAG, "IllegalArgumentException caught throttleDevice() "); |
| } catch (ExceptionInInitializerError e) { |
| Log.i(TAG, "ExceptionInInitializerError caught throttleDevice() "); |
| } catch (SecurityException e) { |
| Log.i(TAG, "SecurityException caught throttleDevice() "); |
| } catch (InvocationTargetException e) { |
| Log.i(TAG, "InvocationTargetException caught throttleDevice() "); |
| } |
| } |
| } else { |
| Log.i(TAG, "throttleDevice: Unable to retrieve cooling device " + coolingDevId); |
| } |
| } |
| |
| public void unregisterReceivers() { |
| if (mContext != null) { |
| mContext.unregisterReceiver(mThermalIntentReceiver); |
| // During Thermal Service init, when parsing fails, we |
| // unregister all receivers here. mProfChangeReceiver |
| // might not have been initialized at that time because |
| // we initialize this only after starting the Default profile. |
| if (mProfChangeListenerInitialized) { |
| mContext.unregisterReceiver(mProfChangeReceiver); |
| } |
| } |
| } |
| } |
