/* Module for handling DALLAS DS2438, smart battery monitor Chip can store up to 40 bytes of user data in EEPROM, perform temp, voltage and current measurements. Chip also contains a unique serial number. Always read/write LSb first For documentaion, see data sheet for DS2438, 2438.pdf By Thomas.Lange@corelatus.com 001025 Copyright (C) 2000-2005 Corelatus AB */ /* This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA */ #include <common.h> #include <command.h> #include <asm/au1x00.h> #include <asm/io.h> #include "ee_dev.h" #include "ee_access.h" /* static int Debug = 1; */ #undef E_DEBUG #define E_DEBUG(fmt,args...) /* */ /* #define E_DEBUG(fmt,args...) printk("EEA:"fmt,##args); */ /* We dont have kernel functions */ #define printk printf #define KERN_DEBUG #define KERN_ERR #define EIO 1 #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif /* lookup table ripped from DS app note 17, understanding and using cyclic redundancy checks... */ static u8 crc_lookup[256] = { 0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65, 157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220, 35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98, 190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255, 70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7, 219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154, 101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36, 248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185, 140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205, 17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80, 175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238, 50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115, 202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139, 87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22, 233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168, 116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53 }; static void write_gpio_data(int value ){ if(value){ /* Tristate */ gpio_tristate(GPIO_EEDQ); } else{ /* Drive 0 */ gpio_clear(GPIO_EEDQ); } } static u8 make_new_crc( u8 Old_crc, u8 New_value ){ /* Compute a new checksum with new byte, using previous checksum as input See DS app note 17, understanding and using cyclic redundancy checks... Also see DS2438, page 11 */ return( crc_lookup[Old_crc ^ New_value ]); } int ee_crc_ok( u8 *Buffer, int Len, u8 Crc ){ /* Check if the checksum for this buffer is correct */ u8 Curr_crc=0; int i; u8 *Curr_byte = Buffer; for(i=0;i<Len;i++){ Curr_crc = make_new_crc( Curr_crc, *Curr_byte); Curr_byte++; } E_DEBUG("Calculated CRC = 0x%x, read = 0x%x\n", Curr_crc, Crc); if(Curr_crc == Crc){ /* Good */ return(TRUE); } printk(KERN_ERR"EE checksum error, Calculated CRC = 0x%x, read = 0x%x\n", Curr_crc, Crc); return(FALSE); } static void set_idle(void){ /* Send idle and keep start time Continous 1 is idle */ WRITE_PORT(1); } static int do_cpu_reset(void){ /* Release reset and verify that chip responds with presence pulse */ int Retries=0; while(Retries<15){ udelay(RESET_LOW_TIME); /* Send reset */ WRITE_PORT(0); udelay(RESET_LOW_TIME); /* Release reset */ WRITE_PORT(1); /* Wait for EEPROM to drive output */ udelay(PRESENCE_TIMEOUT); if(!READ_PORT){ /* Ok, EEPROM is driving a 0 */ E_DEBUG("Presence detected\n"); if(Retries){ E_DEBUG("Retries %d\n",Retries); } /* Make sure chip releases pin */ udelay(PRESENCE_LOW_TIME); return 0; } Retries++; } printk(KERN_ERR"eeprom did not respond when releasing reset\n"); /* Make sure chip releases pin */ udelay(PRESENCE_LOW_TIME); /* Set to idle again */ set_idle(); return(-EIO); } static u8 read_cpu_byte(void){ /* Read a single byte from EEPROM Read LSb first */ int i; int Value; u8 Result=0; u32 Flags; E_DEBUG("Reading byte\n"); for(i=0;i<8;i++){ /* Small delay between pulses */ udelay(1); #ifdef __KERNEL__ /* Disable irq */ save_flags(Flags); cli(); #endif /* Pull down pin short time to start read See page 26 in data sheet */ WRITE_PORT(0); udelay(READ_LOW); WRITE_PORT(1); /* Wait for chip to drive pin */ udelay(READ_TIMEOUT); Value = READ_PORT; if(Value) Value=1; #ifdef __KERNEL__ /* Enable irq */ restore_flags(Flags); #endif /* Wait for chip to release pin */ udelay(TOTAL_READ_LOW-READ_TIMEOUT); /* LSb first */ Result|=Value<<i; /* E_DEBUG("Read %d\n",Value); */ } E_DEBUG("Read byte 0x%x\n",Result); return(Result); } static void write_cpu_byte(u8 Byte){ /* Write a single byte to EEPROM Write LSb first */ int i; int Value; u32 Flags; E_DEBUG("Writing byte 0x%x\n",Byte); for(i=0;i<8;i++){ /* Small delay between pulses */ udelay(1); Value = Byte&1; #ifdef __KERNEL__ /* Disable irq */ save_flags(Flags); cli(); #endif /* Pull down pin short time for a 1, long time for a 0 See page 26 in data sheet */ WRITE_PORT(0); if(Value){ /* Write a 1 */ udelay(WRITE_1_LOW); } else{ /* Write a 0 */ udelay(WRITE_0_LOW); } WRITE_PORT(1); #ifdef __KERNEL__ /* Enable irq */ restore_flags(Flags); #endif if(Value) /* Wait for chip to read the 1 */ udelay(TOTAL_WRITE_LOW-WRITE_1_LOW); /* E_DEBUG("Wrote %d\n",Value); */ Byte>>=1; } } int ee_do_cpu_command( u8 *Tx, int Tx_len, u8 *Rx, int Rx_len, int Send_skip ){ /* Execute this command string, including giving reset and setting to idle after command if Rx_len is set, we read out data from EEPROM */ int i; E_DEBUG("Command, Tx_len %d, Rx_len %d\n", Tx_len, Rx_len ); if(do_cpu_reset()){ /* Failed! */ return(-EIO); } if(Send_skip) /* Always send SKIP_ROM first to tell chip we are sending a command, except when we read out rom data for chip */ write_cpu_byte(SKIP_ROM); /* Always have Tx data */ for(i=0;i<Tx_len;i++){ write_cpu_byte(Tx[i]); } if(Rx_len){ for(i=0;i<Rx_len;i++){ Rx[i]=read_cpu_byte(); } } set_idle(); E_DEBUG("Command done\n"); return(0); } int ee_init_cpu_data(void){ int i; u8 Tx[10]; /* Leave it floting since altera is driving the same pin */ set_idle(); /* Copy all User EEPROM data to scratchpad */ for(i=0;i<USER_PAGES;i++){ Tx[0]=RECALL_MEMORY; Tx[1]=EE_USER_PAGE_0+i; if(ee_do_cpu_command(Tx,2,NULL,0,TRUE)) return(-EIO); } /* Make sure chip doesnt store measurements in NVRAM */ Tx[0]=WRITE_SCRATCHPAD; Tx[1]=0; /* Page */ Tx[2]=9; if(ee_do_cpu_command(Tx,3,NULL,0,TRUE)) return(-EIO); Tx[0]=COPY_SCRATCHPAD; if(ee_do_cpu_command(Tx,2,NULL,0,TRUE)) return(-EIO); for(i=0;i<10;i++){ udelay(1000); } return(0); }