eepromutil.c

   1 /*
   2  * OpenI2CRADIO
   3  * EEPROM utils
   4  * Copyright (C) 2013-06-10 K.Ohta <whatisthis.sowhat ai gmail.com>
   5  * License: GPL2+LE
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2,
  10  *  or (at your option) any later version.
  11  *  This library / program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  *  See the GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this library; see the file COPYING. If not, write to the
  18  *  Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
  19  *  MA 02110-1301, USA.
  20  *
  21  *  As a special exception, if you link this(includeed from sdcc) library
  22  *  with other files, some of which are compiled with SDCC,
  23  *  to produce an executable, this library does not by itself cause
  24  *  the resulting executable to be covered by the GNU General Public License.
  25  *  This exception does not however invalidate any other reasons why
  26  *  the executable file might be covered by the GNU General Public License.
  27  */
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #if defined(__SDCC)
  34 #include <sdcc-lib.h>
  35 #include <pic18fregs.h> /* ONLY FOR PIC18x */
  36 #include <delay.h>
  37 #else
  38 #include <xc.h>
  39 #endif
  40 #include <signal.h>
  41
  42 #include "commondef.h"
  43 #include "iodef.h"
  44 #include "idle.h"
  45 #include "i2c_io.h"
  46 #include "i2c_eeprom.h"
  47 #include "akc6955.h"
  48 #include "lcd_acm1602.h"
  49 #include "ui.h"
  50 #include "eeprom.h"
  51 #include "ioports.h"
  52 #include "menu.h"
  53 #include "power.h"
  54 #include "adc_int.h"
  55
  56 void save_eeprom(void)
  57 {
  58     unsigned int p[1];
  59     unsigned int sum[1];
  60         unsigned char i;
  61     unsigned char j;
  62     unsigned char *q = (char *)(&setup);
  63
  64     *p = 0;
  65     *sum = 0;
  66     // Magic word
  67     writeword_eeprom(p, sum, 0x1298);
  68     // amfreq
  69     for(i = 0; i < sizeof(__radioset_t); i++) {
  70         writebyte_eeprom(p, sum, *q);
  71         q++;
  72     }
  73
  74     // Write checksum
  75     eeprom_writebyte(*p, sum[0] >> 8);
  76     eeprom_writebyte(*p + 1, sum[0] & 0xff);
  77 }
  78
  79
  80 unsigned int calcsum_frequencies(__freqset_t *p, unsigned int start)
  81 {
  82     unsigned int sum = start;
  83     unsigned char *q = (unsigned char *)p;
  84     unsigned char c;
  85     unsigned char i;
  86
  87     for(i = 0; i < (sizeof(__freqset_t) - 2); i++){
  88         c = *q;
  89         q++;
  90         sum = sum + c;
  91     }
  92     return sum;
  93 }
  94 /*
  95   * External I2C Map:
  96  *  0x0000
  97  *  0x00FF : User settings(Reserved not use)
  98  *  0x0100
  99  *  0x03ff : User bands
 100  *  0x0400
 101  *  0x0fff : User frequencies ( 12*2*28 = 672chs Max.)
 102  *  0x1000- : Reserve.
 103  */
 104 char load_frequencies(unsigned int page, unsigned char check_only)
 105 {
 106
 107     __freqset_t *p;
 108     unsigned int sum;
 109     unsigned int addr = (page << 7) + 512;
 110     unsigned char *q;
 111     unsigned char *r;
 112     unsigned char c;
 113     unsigned int i;
 114
 115 //    if(addr > 0x0fff) return -1; // Address error
 116     if(page > USER_MEMORY_BANKS) return -1; // Address Error
 117     p = &freqset_temp;
 118     c = i2c_eeprom_burstread(I2CEEPROM_ADDR, addr, (unsigned char *)p, sizeof(__freqset_t));
 119     // Pass 1 Read OK?
 120     if(c == 0x00) return -2;
 121     // Pass 1 check magic
 122     if(freqset_temp.magic != 0xfabc) return -3;
 123     // Pass 2 check sum
 124     sum = calcsum_frequencies(&freqset_temp, 0xa5a5);
 125     if(sum != freqset_temp.checksum) return -4;
 126     // Move from
 127     if(check_only == 0x00){
 128         q = (unsigned char *)(&freqset_temp);
 129         r = (unsigned char *)(&freqset);
 130         for(i = 0; i < sizeof(__freqset_t); i++){
 131             *r = *q;
 132             q++;
 133             r++;
 134         }
 135         setup.pagenum = page;
 136     }
 137     return 0;
 138 }
 139
 140
 141
 142 void save_frequencies(void)
 143 {
 144     unsigned char c;
 145     unsigned int addr = (setup.pagenum <<7) + 512;
 146     __freqset_t *p = &freqset;
 147     unsigned char i;
 148     unsigned int sum;
 149
 150     if(setup.pagenum > USER_MEMORY_BANKS) return; // Address Error
 151     // Pass 0 Calc checksum
 152     freqset.magic = 0xfabc;
 153     freqset.version = 0x0001;
 154     sum = calcsum_frequencies(&freqset, 0xa5a5);
 155     freqset.checksum = sum;
 156     // Pass 1 write to rom.
 157     c = i2c_eeprom_burstwrite(I2CEEPROM_ADDR, addr, (unsigned char *)p, sizeof(__freqset_t));
 158     return;
 159 }
 160
 161 void format_frequencies(unsigned int page)
 162 {
 163     unsigned char i;
 164     unsigned int sum;
 165
 166     freqset_temp.magic = 0xfabc;
 167     freqset_temp.version = 0x0001;
 168     for(i = 0; i < USER_MEMORY_NUM; i++){
 169         freqset_temp.memoryfreqs[i].band = AKC6955_BAND_MW2;
 170         freqset_temp.memoryfreqs[i].fm = 0;
 171         freqset_temp.memoryfreqs[i].freq = 594;
 172     }
 173     freqset_temp.pagenum = page;
 174     sum = calcsum_frequencies(&freqset_temp, 0xa5a5);
 175     freqset_temp.checksum = sum;
 176
 177     i = i2c_eeprom_burstwrite(I2CEEPROM_ADDR, (page << 7)+ 512, (unsigned char *)(&freqset_temp), sizeof(__freqset_t));
 178 }
 179
 180 void check_frequencies(void)
 181 {
 182     unsigned int i;
 183     _CLS();
 184     for(i = 0; i < USER_MEMORY_BANKS; i++){
 185         printstr("Check ExtROM:");
 186         print_numeric_nosupress(i, 2);
 187        _HOME();
 188
 189         if(load_frequencies(i, 0xff) < 0){
 190             printstr("Format:");
 191             print_numeric_nosupress(i, 2);
 192             _HOME();
 193             format_frequencies(i);
 194         }
 195     }
 196 }
 197
 198 unsigned char load_eeprom(void)
 199 {
 200     unsigned int p[1];
 201     unsigned int sum[1];
 202     unsigned char i;
 203     unsigned char *q = (unsigned char *)(&setup);
 204     unsigned char j;
 205     unsigned int magic;
 206
 207     p[0] = 0;
 208     sum[0] = 0;
 209     // Magic word
 210     magic = readword_eeprom(p, sum);
 211     if(magic != 0x1298) return 0x01; // NO MAGICWORD
 212     // amfreq
 213     for(i = 0; i < sizeof(__radioset_t); i++ ){
 214         *q = readbyte_eeprom(p, sum);
 215         q++;
 216     }
 217     magic = (eeprom_readbyte(p[0]) << 8) + eeprom_readbyte(p[0] + 1);
 218
 219     if(sum[0] != magic) return 0x00;
 220     return 0xff;
 221 }
 222
 223 /*
 224  * Check eeprom, and format/restore.
 225  */
 226 static void check_eeprom_sub(void)
 227 {
 228  _CLS();
 229  _LOCATE(0,0);
 230  printstr("Formatting...  ");
 231  format_eeprom(2,250);
 232  _LOCATE(0,0);
 233  printstr("Save defaults  ");
 234  setdefault();
 235  save_eeprom();
 236 }
 237
 238
 239 void check_eeprom(void)
 240 {
 241     unsigned char c;
 242
 243     switch(load_eeprom()) {
 244         case 0x01: // No magic-word
 245             idle_time_ms(2000);
 246             c = printhelp_2lines("EEPROM FORMAT", "Press any key");
 247             check_eeprom_sub();
 248             break;
 249         case 0x00: // Checksum error
 250            idle_time_ms(2000);
 251             c = printhelp_2lines("X-) Sum error", "Press any key");
 252             check_eeprom_sub();
 253             break;
 254         case 0xff: // Success
 255             check_frequencies();
 256             load_frequencies(setup.pagenum, 0);
 257             return;
 258             break;
 259         default: // Unknown error
 260             break;
 261     }
 262     valinit();
 263     check_frequencies();
 264     load_frequencies(setup.pagenum, 0);
 265 }