/*

   This Source Code Form is subject to the terms of the Mozilla Public

   License, v. 2.0. If a copy of the MPL was not distributed with this

   file, You can obtain one at http://mozilla.org/MPL/2.0/.

   Copyright (C) 2009-2011 Michael Möller <mmoeller@openhardwaremonitor.org>

 */

 using System;

 using System.Globalization;

 namespace OpenHardwareMonitor.Hardware.ATI {

   internal sealed class ATIGPU : Hardware {

     private readonly int adapterIndex;

     private readonly int busNumber;

     private readonly int deviceNumber;

     private readonly Sensor temperature;

     private readonly Sensor fan;

     private readonly Sensor coreClock;

     private readonly Sensor memoryClock;

     private readonly Sensor coreVoltage;

     private readonly Sensor coreLoad;

     private readonly Sensor controlSensor;

     private readonly Control fanControl;

     private bool restoreDefaultFanSpeedRequired = false;

     private ADLFanSpeedValue initialFanSpeedValue;    

     public ATIGPU(string name, int adapterIndex, int busNumber, 

       int deviceNumber, ISettings settings) 

       : base(name, new Identifier("atigpu", 

         adapterIndex.ToString(CultureInfo.InvariantCulture)), settings)

     {

       this.adapterIndex = adapterIndex;

       this.busNumber = busNumber;

       this.deviceNumber = deviceNumber;

       this.temperature = new Sensor("GPU Core", 0, SensorType.Temperature, this, settings);

       this.fan = new Sensor("GPU Fan", 0, SensorType.Fan, this, settings);

       this.coreClock = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);

       this.memoryClock = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);

       this.coreVoltage = new Sensor("GPU Core", 0, SensorType.Voltage, this, settings);

       this.coreLoad = new Sensor("GPU Core", 0, SensorType.Load, this, settings);

       this.controlSensor = new Sensor("GPU Fan", 0, SensorType.Control, this, settings);

       ADLFanSpeedInfo afsi = new ADLFanSpeedInfo();

       if (ADL.ADL_Overdrive5_FanSpeedInfo_Get(adapterIndex, 0, ref afsi)

         != ADL.ADL_OK) 

       {

         afsi.MaxPercent = 100;

         afsi.MinPercent = 0;

       }

       this.fanControl = new Control(controlSensor, settings, afsi.MinPercent, 

         afsi.MaxPercent);

       this.fanControl.ControlModeChanged += ControlModeChanged;

       this.fanControl.SoftwareControlValueChanged += 

         SoftwareControlValueChanged;

       ControlModeChanged(fanControl);

       this.controlSensor.Control = fanControl;

       Update();                   

     }

     private void SaveDefaultFanSpeed() {

       if (!restoreDefaultFanSpeedRequired) {        

         initialFanSpeedValue = new ADLFanSpeedValue();

         initialFanSpeedValue.SpeedType =

           ADL.ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;

         restoreDefaultFanSpeedRequired = 

           ADL.ADL_Overdrive5_FanSpeed_Get(adapterIndex, 0,

           ref initialFanSpeedValue) == ADL.ADL_OK;

       }

     }

     private void RestoreDefaultFanSpeed() {

       if (restoreDefaultFanSpeedRequired) {        

         ADL.ADL_Overdrive5_FanSpeed_Set(adapterIndex, 0,

           ref this.initialFanSpeedValue);

         if ((initialFanSpeedValue.Flags &

           ADL.ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED) == 0)

           ADL.ADL_Overdrive5_FanSpeedToDefault_Set(adapterIndex, 0);

         restoreDefaultFanSpeedRequired = false;

       }

     }

     private void SoftwareControlValueChanged(IControl control) {

       if (control.ControlMode == ControlMode.Software) {

         SaveDefaultFanSpeed();

         ADLFanSpeedValue adlf = new ADLFanSpeedValue();

         adlf.SpeedType = ADL.ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;

         adlf.Flags = ADL.ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED;

         adlf.FanSpeed = (int)control.SoftwareValue;

         ADL.ADL_Overdrive5_FanSpeed_Set(adapterIndex, 0, ref adlf);

       }

     }

     private void ControlModeChanged(IControl control) {

       if (control.ControlMode == ControlMode.Default) {

         RestoreDefaultFanSpeed();     

       } else {

         SoftwareControlValueChanged(control);

       }

     }

     public int BusNumber { get { return busNumber; } }

     public int DeviceNumber { get { return deviceNumber; } }

     public override HardwareType HardwareType {

       get { return HardwareType.GpuAti; }

     }

     public override void Update() {

       ADLTemperature adlt = new ADLTemperature();

       if (ADL.ADL_Overdrive5_Temperature_Get(adapterIndex, 0, ref adlt)

         == ADL.ADL_OK) 

       {

         temperature.Value = 0.001f * adlt.Temperature;

         ActivateSensor(temperature);

       } else {

         temperature.Value = null;

       }

       ADLFanSpeedValue adlf = new ADLFanSpeedValue();

       adlf.SpeedType = ADL.ADL_DL_FANCTRL_SPEED_TYPE_RPM;

       if (ADL.ADL_Overdrive5_FanSpeed_Get(adapterIndex, 0, ref adlf)

         == ADL.ADL_OK) 

       {

         fan.Value = adlf.FanSpeed;

         ActivateSensor(fan);

       } else {

         fan.Value = null;

       }

       adlf = new ADLFanSpeedValue();

       adlf.SpeedType = ADL.ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;

       if (ADL.ADL_Overdrive5_FanSpeed_Get(adapterIndex, 0, ref adlf)

         == ADL.ADL_OK) {

         controlSensor.Value = adlf.FanSpeed;

         ActivateSensor(controlSensor);

       } else {

         controlSensor.Value = null;

       }

       ADLPMActivity adlp = new ADLPMActivity();

       if (ADL.ADL_Overdrive5_CurrentActivity_Get(adapterIndex, ref adlp)

         == ADL.ADL_OK) 

       {

         if (adlp.EngineClock > 0) {

           coreClock.Value = 0.01f * adlp.EngineClock;

           ActivateSensor(coreClock);

         } else {

           coreClock.Value = null;

         }

         if (adlp.MemoryClock > 0) {

           memoryClock.Value = 0.01f * adlp.MemoryClock;

           ActivateSensor(memoryClock);

         } else {

           memoryClock.Value = null;

         }

         if (adlp.Vddc > 0) {

           coreVoltage.Value = 0.001f * adlp.Vddc;

           ActivateSensor(coreVoltage);

         } else {

           coreVoltage.Value = null;

         }

         coreLoad.Value = Math.Min(adlp.ActivityPercent, 100);                        

         ActivateSensor(coreLoad);

       } else {

         coreClock.Value = null;

         memoryClock.Value = null;

         coreVoltage.Value = null;

         coreLoad.Value = null;

       }

     }

     public override void Close() {

       this.fanControl.ControlModeChanged -= ControlModeChanged;

       this.fanControl.SoftwareControlValueChanged -=

         SoftwareControlValueChanged;

       RestoreDefaultFanSpeed();

       base.Close();

     }

   }

 }