max8971.cpp

00001 /*******************************************************************************
00002  * Copyright (C) 2018 Maxim Integrated Products, Inc., All Rights Reserved.
00003  *
00004  * Permission is hereby granted, free of charge, to any person obtaining a
00005  * copy of this software and associated documentation files (the "Software"),
00006  * to deal in the Software without restriction, including without limitation
00007  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
00008  * and/or sell copies of the Software, and to permit persons to whom the
00009  * Software is furnished to do so, subject to the following conditions:
00010  *
00011  * The above copyright notice and this permission notice shall be included
00012  * in all copies or substantial portions of the Software.
00013  *
00014  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00015  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00016  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00017  * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
00018  * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
00019  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
00020  * OTHER DEALINGS IN THE SOFTWARE.
00021  *
00022  * Except as contained in this notice, the name of Maxim Integrated
00023  * Products, Inc. shall not be used except as stated in the Maxim Integrated
00024  * Products, Inc. Branding Policy.
00025  *
00026  * The mere transfer of this software does not imply any licenses
00027  * of trade secrets, proprietary technology, copyrights, patents,
00028  * trademarks, maskwork rights, or any other form of intellectual
00029  * property whatsoever. Maxim Integrated Products, Inc. retains all
00030  * ownership rights.
00031  *******************************************************************************
00032  */
00033  #include "max8971.h"
00034  
00035 /***** Definitions *****/
00036 #define I2C_ADDR            (0x35<<1)
00037  
00038 /**
00039   * max8971 constructor.
00040   *
00041   * @param i2c I2C object to use.
00042   */
00043 MAX8971::MAX8971(I2C *i2c) :
00044     i2c_(i2c)
00045 {
00046     i2c_owner = false;
00047 }
00048  
00049 /**
00050   * max8971 destructor.
00051   */
00052 MAX8971::~MAX8971()
00053 {
00054     if(i2c_owner) {
00055         delete i2c_;
00056     }
00057 }
00058 
00059 /**
00060   * @brief   Initialize max8971
00061   */
00062 int32_t MAX8971::init()
00063 {     
00064     // insert initial setting functions
00065     return 0;
00066 }
00067  
00068 /**
00069   * @brief   Read Register
00070   * @details Reads data from max8971 register
00071   *
00072   * @param   reg_addr Register to read
00073   * @returns data if no errors, -1 if error.
00074   */
00075 int32_t MAX8971::read_register(MAX8971::registers_t reg_no)
00076 {
00077     char data;
00078  
00079     data = reg_no;
00080     if (i2c_->write(I2C_ADDR, &data, 1, true) != 0) {
00081         return -1;
00082     }
00083  
00084     if (i2c_->read(I2C_ADDR | 0x01, &data, 1) != 0) {
00085         return -1;
00086     }
00087  
00088     return (0x0 + data);
00089 }
00090  
00091 /**
00092   * @brief   Write Register
00093   * @details Writes data to MAX77756 register
00094   *
00095   * @param   reg_addr Register to write
00096   * @param   reg_data Data to write
00097   * @returns 0 if no errors, -1 if error.
00098   */
00099 int32_t MAX8971::write_register(MAX8971::registers_t reg_no, char reg_data)
00100 {
00101     char data[2];
00102  
00103     data[0] = reg_no;
00104     data[1] = reg_data;
00105     if (i2c_->write(I2C_ADDR, data, 2) != 0) {
00106         return -1;
00107     }
00108  
00109     return 0;
00110 }
00111 
00112 /**
00113   * @brief   Update Register data
00114   * @details Update bits data of a register 
00115   *
00116   * @param   reg_no Register Number to be updated
00117   * @param   mask Mask Data
00118   * @param   reg_data bit data
00119   * @returns 0 if no errors, -1 if error.
00120   */
00121 int32_t MAX8971::update_register
00122 (MAX8971::registers_t reg_no, char reg_mask,  char reg_data)
00123 {
00124     int32_t data;
00125  
00126     data = read_register(reg_no);
00127     if(data < 0)
00128         return -1;
00129     
00130     data &= ~reg_mask;
00131     data |= reg_data;
00132     
00133     data = write_register(reg_no, (char)(data & 0xff));
00134     if(data < 0)
00135         return -1;
00136     return 0;
00137 }
00138 
00139 /**
00140   * @brief   Get Interrupt
00141   * @details Get status register data
00142   *          BIT7 : AICL_I DC Interrupt
00143   *          BIT6 : TOPOFF Topoff Interrupt
00144   *          BIT5 : DC Overvolatage Interrupt
00145   *          BIT4 : DC Undervoltage Interrupt
00146   *          BIT3 : Charge Current Interrupt
00147   *          BIT2 : Battery Interrupt
00148   *          BIT1 : Thermistor Interrupt
00149   *          BIT0 : Power-Up OK Interrupt
00150   * @param   None
00151   * @returns Interrupt register data.
00152   */
00153 int32_t MAX8971::get_interrupt()
00154 {    
00155     int32_t data;
00156     
00157     data = read_register(REG_CHG_STAT);
00158     if(data < 0)
00159         return -1;
00160     return (data & 0xFF);
00161 }
00162 
00163 /**
00164   * @brief   Set Interrupt Mask
00165   * @details Get status register data
00166   *          BIT7 : AICL_I DC Interrupt
00167   *          BIT6 : TOPOFF Topoff Interrupt
00168   *          BIT5 : DC Overvolatage Interrupt
00169   *          BIT4 : DC Undervoltage Interrupt
00170   *          BIT3 : Charge Current Interrupt
00171   *          BIT2 : Battery Interrupt
00172   *          BIT1 : Thermistor Interrupt
00173   *          BIT0 : Reserved
00174   * @param   Register Number, Interrupt Bit
00175   * @returns Interrupt register data.
00176   */
00177 int32_t MAX8971::set_interrupt_mask
00178 (MAX8971::registers_t reg_no, MAX8971::int_bit_t interrupt_bit)
00179 {   
00180     char mask_bit;
00181     int32_t data;
00182     
00183     if(interrupt_bit <VAL_THM_I_BIT)
00184         return -1;
00185         
00186     mask_bit = 0x01 << interrupt_bit;
00187     data = update_register(REG_CHGINT_MASK, mask_bit, mask_bit);
00188     if(data < 0)
00189         return -1;
00190         
00191     data = read_register(REG_CHGINT_MASK);
00192     if(data < 0)
00193         return -1;
00194     return (data & 0xFF);
00195 }
00196 
00197 /**
00198   * @brief   Set Interrupt UnMask
00199   * @details Get status register data
00200   *          BIT7 : AICL_I DC Interrupt
00201   *          BIT6 : TOPOFF Topoff Interrupt
00202   *          BIT5 : DC Overvolatage Interrupt
00203   *          BIT4 : DC Undervoltage Interrupt
00204   *          BIT3 : Charge Current Interrupt
00205   *          BIT2 : Battery Interrupt
00206   *          BIT1 : Thermistor Interrupt
00207   *          BIT0 : Reserved
00208   * @param   Register Number, Interrupt Bit
00209   * @returns Interrupt register data.
00210   */
00211 int32_t MAX8971::set_interrupt_unmask
00212 (MAX8971::registers_t reg_no, MAX8971::int_bit_t interrupt_bit)
00213 {   
00214     char mask_bit;
00215     int32_t data;
00216     
00217     if(interrupt_bit <VAL_THM_I_BIT)
00218         return -1;
00219         
00220     mask_bit = 0x01 << interrupt_bit;
00221     data = update_register(REG_CHGINT_MASK, mask_bit, 0);
00222     if(data < 0)
00223         return -1;
00224         
00225     data = read_register(REG_CHGINT_MASK);
00226     if(data < 0)
00227         return -1;
00228     return (data & 0xFF);
00229 }
00230 
00231 /**
00232   * @brief   Get status
00233   * @details Get status register data
00234   *          BIT7 : DCV_OK DC Input Voltage Status
00235   *          BIT6 : DCI_OK DC Input Current Status
00236   *          BIT5 : DCOVP_OK DC OVP Status
00237   *          BIT4 : DCUVP_OK DC UVP Status
00238   *          BIT3 : CHG_OK Charger Status
00239   *          BIT2 : BAT_OK Battery Status
00240   *          BIT1 : THM_OK Thermistor Status
00241   *          BIT0 : RESERVED
00242   * @param   None
00243   * @returns status register data.
00244   */
00245 int32_t MAX8971::get_status()
00246 {    
00247     int32_t data;
00248     
00249     data = read_register(REG_CHG_STAT);
00250     if(data < 0)
00251         return -1;
00252     return (data & 0xFE);
00253 }
00254 
00255 
00256 /**
00257   * @brief   Get Details 1
00258   * @details Get Details 1 register data
00259   *          BIT7 : DC Details
00260   *          BIT6 : DC Current
00261   *          BIT5 : DC OVP
00262   *          BIT4 : DC UVP
00263   *          BIT3 : RESERVED
00264   *          BIT2-0 : Thermistor Details
00265   * @param   None
00266   * @returns status details 1 register data.
00267   */
00268 int32_t MAX8971::get_details1()
00269 {    
00270     int32_t data;
00271     
00272     data = read_register(REG_DETAILS1);
00273     if(data < 0)
00274         return -1;
00275     return (data & 0xF7);
00276 }
00277 
00278 /**
00279   * @brief   Get Details 2
00280   * @details Get Details 2 register data
00281   *          BIT7-6 : Reserved
00282   *          BIT5-4 : Battery Details
00283   *          BIT3-0 : Charger Details
00284   * @param   None
00285   * @returns status details 2 register data.
00286   */
00287 int32_t MAX8971::get_details2()
00288 {    
00289     int32_t data;
00290     
00291     data = read_register(REG_DETAILS2);
00292     if(data < 0)
00293         return -1;
00294     return (data & 0x3F);
00295 }
00296 
00297 /**
00298   * @brief   Set DCMON_DIS
00299   * @details Set to disable the monitoring of input voltage
00300   *          by the input power limiter
00301   * @param   None
00302   * @returns DCMON_DIS bit data.
00303   */
00304 int32_t MAX8971::set_disable_dc_monitor()
00305 {    
00306     int32_t shift = 1;   
00307     char mask_bit = 0x01 << shift;
00308     int32_t data;
00309     
00310     data = update_register(REG_CHGCNTL1, mask_bit, 1);
00311     if(data < 0)
00312         return -1;
00313         
00314     data = read_register(REG_CHGCNTL1);
00315     if(data < 0)
00316         return -1;
00317     return ( (data & mask_bit) >> shift);
00318 }
00319 
00320 /**
00321   * @brief   UnSet DCMON_DIS
00322   * @details UnSet to enable the monitoring of input voltage
00323   *          by the input power limiter
00324   * @param   None
00325   * @returns DCMON_DIS bit data.
00326   */
00327 int32_t MAX8971::unset_disable_dc_monitor()
00328 {       
00329     int32_t shift = 1;   
00330     char mask_bit = 0x01 << shift;
00331     int32_t data;
00332     
00333     data = update_register(REG_CHGCNTL1, mask_bit, 0);
00334     if(data < 0)
00335         return -1;
00336         
00337     data = read_register(REG_CHGCNTL1);
00338     if(data < 0)
00339         return -1;
00340     return ( (data & mask_bit) >> shift);
00341 }
00342 
00343 /**
00344   * @brief   Set USB SUSPEND
00345   * @details Set to USB Suspend bit 
00346   * @param   None
00347   * @returns USB SUSPEND bit data.
00348   */
00349 int32_t MAX8971::set_usb_suspend()
00350 {    
00351     int32_t data;
00352     
00353     data = update_register(REG_CHGCNTL1, 0x01, 1);
00354     if(data < 0)
00355         return -1;
00356         
00357     data = read_register(REG_CHGCNTL1);
00358     if(data < 0)
00359         return -1;
00360     return ( data & 0x01);
00361 }
00362 
00363 /**
00364   * @brief   UnSet USB SUSPEND
00365   * @details UnSet to USB Suspend bit 
00366   * @param   None
00367   * @returns USB SUSPEND bit data.
00368   */
00369 int32_t MAX8971::unset_usb_suspend()
00370 {    
00371     int32_t data;
00372         
00373     data = update_register(REG_CHGCNTL1, 0x01, 0);
00374     if(data < 0)
00375         return -1;
00376         
00377     data = read_register(REG_CHGCNTL1);
00378     if(data < 0)
00379         return -1;
00380     return ( data & 0x01);
00381 }
00382 
00383 
00384 /**
00385   * @brief   Set Fast Charge Current
00386   * @details Set to CHGCC bit to control Fast Charge Current
00387   * @param   int 0-1550
00388   * @returns Fast Charge Current Bit Data.
00389   */
00390 int32_t MAX8971::set_fast_charge_current(int current)
00391 {    
00392     char mask_bit = 0x1f;
00393     char value_bit = 0x0;
00394     int32_t data;
00395     
00396     switch(current)
00397     {
00398         case 0 ... 249:
00399             value_bit = 0x0;
00400             break;
00401         case 250 ... 1550:
00402             value_bit = current/50;
00403             break;
00404         default: 
00405             value_bit = 0x1f;
00406             break;         
00407     }    
00408     
00409     data = update_register(REG_FCHGCRNT, mask_bit, value_bit);
00410     if(data < 0)
00411         return -1;
00412         
00413     data = read_register(REG_FCHGCRNT);
00414     if(data < 0)
00415         return -1;
00416     return ( data & mask_bit);
00417 }
00418 
00419 /**
00420   * @brief   Set Fast Charge Timer Duration
00421   * @details Set to FCHGT bit to control Fast Charge Timer
00422   * @param   fast_charge_timer_t
00423   * @returns Fast Charge Timer Bit Data.
00424   */
00425 int32_t MAX8971::set_fast_charge_timer(MAX8971::fast_charge_timer_t fc_time)
00426 {    
00427     char mask_bit = 0xE0;    
00428     int32_t shift = 5;   
00429     int32_t data;       
00430     
00431     data = update_register(REG_FCHGCRNT, mask_bit, fc_time<<shift);
00432     if(data < 0)
00433         return -1;
00434         
00435     data = read_register(REG_FCHGCRNT);
00436     if(data < 0)
00437         return -1;
00438     return ( (data & mask_bit) >> shift);
00439 }
00440 
00441 /**
00442   * @brief   Set Fast Restart Threshold
00443   * @details Set to CHGRSTRT bit to control Fast Restart Threshold
00444   * @param   fast_charge_restart_threshold_t
00445   * @returns CHGRSTRT bit Data.
00446   */
00447 int32_t MAX8971::set_fast_charge_restart_threshold
00448 (MAX8971::fast_charge_restart_threshold_t voltage)
00449 {    
00450     char mask_bit = 0x40;    
00451     int32_t shift = 6;   
00452     int32_t data;       
00453     
00454     data = update_register(REG_DCCRNT, mask_bit, voltage<<shift);
00455     if(data < 0)
00456         return -1;
00457         
00458     data = read_register(REG_DCCRNT);
00459     if(data < 0)
00460         return -1;
00461     return ( (data & mask_bit) >> shift);
00462 }
00463 
00464 /**
00465   * @brief   Set Input Current Limit
00466   * @details Set to DCILMT to control Input Current Limit
00467   *          0x00 - 0x09 : 100mA
00468   *          0x10 - 1x3C : 250 mA - 1500 mA with 25m A
00469   * @param   int 0-1500
00470   * @returns DCILMT bit Data.
00471   */
00472 int32_t MAX8971::set_input_current_limit(int limit)
00473 {    
00474     char mask_bit = 0x3F;    
00475     char value_bit = 0;   
00476     int32_t data; 
00477         
00478     switch(limit)
00479     {
00480         case 0 ... 99:
00481             value_bit = 0x3f; // disable
00482             break;
00483         case 100 ... 249:
00484             value_bit = 0x09;
00485             break;
00486         case 250 ... 1500:
00487             value_bit = limit/25;
00488             break;
00489         default: 
00490             value_bit = 0x3c; //maximum current is 1500mA(0x3C)
00491             break;         
00492     }    
00493     
00494     data = update_register(REG_DCCRNT, mask_bit, value_bit);
00495     if(data < 0)
00496         return -1;
00497         
00498     data = read_register(REG_DCCRNT);
00499     if(data < 0)
00500         return -1;
00501     return ( data & mask_bit);
00502 }
00503 
00504 /**
00505   * @brief   Set Topoff Timer
00506   * @details Set to TOFFT bit to control Topoff Timer
00507   * @param   top_off_timer_t
00508   * @returns TOFFT bit Data.
00509   */
00510 int32_t MAX8971::set_top_off_timer(MAX8971::top_off_timer_t time)
00511 {    
00512     char mask_bit = 0xE0;    
00513     int32_t shift = 5;   
00514     int32_t data;       
00515     
00516     data = update_register(REG_TOPOFF, mask_bit, time<<shift);
00517     if(data < 0)
00518         return -1;
00519         
00520     data = read_register(REG_TOPOFF);
00521     if(data < 0)
00522         return -1;
00523     return ( (data & mask_bit) >> shift);
00524 }
00525 
00526 
00527 /**
00528   * @brief   Set Topoff Current Threshold
00529   * @details Set to TOFFS bit to control Topoff Current Threshold
00530   * @param   top_off_current_threshold_t
00531   * @returns TOFFS bit Data.
00532   */
00533 int32_t MAX8971::set_top_off_current_threshold
00534 (MAX8971::top_off_current_threshold_t current)
00535 {    
00536     char mask_bit = 0x0C;    
00537     int32_t shift = 2;   
00538     int32_t data;       
00539     
00540     data = update_register(REG_TOPOFF, mask_bit, current<<shift);
00541     if(data < 0)
00542         return -1;
00543         
00544     data = read_register(REG_TOPOFF);
00545     if(data < 0)
00546         return -1;
00547     return ( (data & mask_bit) >> shift);
00548 }
00549 
00550 
00551 /**
00552   * @brief   Set Charge Termination Voltage
00553   * @details Set to CHGCV bit to control Charge Termination Voltage in CV Mode
00554   * @param   charger_termination_voltage_t
00555   * @returns CHGCV bit Data.
00556   */
00557 int32_t MAX8971::set_charge_termination_voltage
00558 (MAX8971::charger_termination_voltage_t voltage)
00559 {    
00560     char mask_bit = 0x03;    
00561     int32_t shift = 0;   
00562     int32_t data;       
00563     
00564     data = update_register(REG_TOPOFF, mask_bit, voltage<<shift);
00565     if(data < 0)
00566         return -1;
00567         
00568     data = read_register(REG_TOPOFF);
00569     if(data < 0)
00570         return -1;
00571     return ( (data & mask_bit) >> shift);
00572 }
00573 
00574 /**
00575   * @brief   Set Die-Temperature Regulation Loop Set Point
00576   * @details Set to REGTEMP bit to control 
00577   *          Die-Temperature Regulation Loop Set Point
00578   * @param   die_temp_reggulation_point_t
00579   * @returns REGTEMP bit Data.
00580   */
00581 int32_t MAX8971::set_charge_termination_voltage
00582 (MAX8971::die_temp_reggulation_point_t degree)
00583 {    
00584     char mask_bit = 0xC0;    
00585     int32_t shift = 6;   
00586     int32_t data;       
00587     
00588     data = update_register(REG_TEMPREG, mask_bit, degree<<shift);
00589     if(data < 0)
00590         return -1;
00591         
00592     data = read_register(REG_TEMPREG);
00593     if(data < 0)
00594         return -1;
00595     return ( (data & mask_bit) >> shift);
00596 }
00597 
00598 /**
00599   * @brief   Set Thermistor Monitor Configuration
00600   * @details Set to THM_CNFG bit to control Thermistor Monitor Configuration
00601   * @param   thermistor_monitor_config_t
00602   * @returns REGTEMP bit Data.
00603   */
00604 int32_t MAX8971::set_thermistor_monitor
00605 (MAX8971::thermistor_monitor_config_t enable)
00606 {    
00607     char mask_bit = 0x08;    
00608     int32_t shift = 3;   
00609     int32_t data;       
00610     
00611     data = update_register(REG_TEMPREG, mask_bit, enable<<shift);
00612     if(data < 0)
00613         return -1;
00614         
00615     data = read_register(REG_TEMPREG);
00616     if(data < 0)
00617         return -1;
00618     return ( (data & mask_bit) >> shift);
00619 }
00620 
00621 /**
00622   * @brief   Set JEITA Safty Region
00623   * @details Set SAFETYREG bit to control JEITA Safty Region
00624   * @param   jeita_safety_selection_t
00625   * @returns SAFETYREG bit Data.
00626   */
00627 int32_t MAX8971::set_jeita_safety_region
00628 (MAX8971::jeita_safety_selection_t enable)
00629 {    
00630     char mask_bit = 0x01;    
00631     int32_t shift = 0;   
00632     int32_t data;       
00633     
00634     data = update_register(REG_TEMPREG, mask_bit, enable<<shift);
00635     if(data < 0)
00636         return -1;
00637         
00638     data = read_register(REG_TEMPREG);
00639     if(data < 0)
00640         return -1;
00641     return ( (data & mask_bit) >> shift);
00642 }
00643 
00644 /**
00645   * @brief   Set Charger-Setting Protection
00646   * @details Set CPROT bit to control Charger-Setting Protection
00647   * @param   charger_setting_protection_t
00648   * @returns CPROT bit Data.
00649   */
00650 int32_t MAX8971::set_charger_setting_protection
00651 (MAX8971::charger_setting_protection_t enable)
00652 {    
00653     char mask_bit = 0x0C;    
00654     int32_t shift = 2;   
00655     int32_t data;       
00656     
00657     data = update_register(REG_PROTCMD, mask_bit, enable<<shift);
00658     if(data < 0)
00659         return -1;
00660         
00661     data = read_register(REG_PROTCMD);
00662     if(data < 0)
00663         return -1;
00664     return ( (data & mask_bit) >> shift);
00665 }