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, EEPROM_INTSET_MAGIC);
  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  *  0x01FF : User settings(Reserved not use)
  98  *  0x0100
  99  *  0x01ff : User bands
 100  *  0x0200
 101  *  0x0fff : User frequencies ( 12*2*28 = 672chs Max.)
 102  *  0x1000- : Reserve.
 103  */
 104 int 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) + EEPROM_FREQSET_ADDR;
 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 != EEPROM_FREQSET_MAGIC) 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) + EEPROM_FREQSET_ADDR;
 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 = EEPROM_FREQSET_MAGIC;
 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 = EEPROM_FREQSET_MAGIC;
 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)+ EEPROM_FREQSET_ADDR, (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    if(load_userbands() < 0) {
 197       format_userbands();
 198    }
 199 }
 200
 201 static unsigned int calcsum_userband(__userband_t_t *p, unsigned int start)
 202 {
 203     unsigned int sum = start;
 204     unsigned char *q = (unsigned char *)p;
 205     unsigned char c;
 206     unsigned char i;
 207
 208     for(i = 0; i < (sizeof(__userband_t_t) - 2); i++){
 209         c = *q;
 210         q++;
 211         sum = sum + c;
 212     }
 213     return sum;
 214 }
 215
 216 int load_userbands(void)
 217 {
 218
 219     __userband_t_t *p = &userband;
 220     unsigned int sum;
 221     unsigned int addr = EEPROM_BANDSET_ADDR;
 222     unsigned char c;
 223
 224 //    if(addr > 0x0fff) return -1; // Address error
 225    c = i2c_eeprom_burstread(I2CEEPROM_ADDR, addr, (unsigned char *)p, sizeof(__userband_t_t));
 226     // Pass 1 Read OK?
 227    if(c == 0x00) return -2;
 228     // Pass 1 check magic
 229    if(p->magic != EEPROM_BANDSET_MAGIC) return -3;
 230     // Pass 2 check sum
 231    sum = calcsum_userband(p, 0x5a5a);
 232    if(sum != p->checksum) return -4;
 233    return 0;
 234 }
 235
 236 void save_userbands(void)
 237 {
 238     unsigned char c;
 239     unsigned int addr = EEPROM_BANDSET_ADDR;
 240     __userband_t_t *p = &userband;
 241     unsigned char i;
 242     unsigned int sum;
 243
 244     // Pass 0 Calc checksum
 245     userband.magic = EEPROM_BANDSET_MAGIC;
 246     userband.version = 0x0001;
 247     sum = calcsum_userband(&userband, 0x5a5a);
 248     userband.checksum = sum;
 249     // Pass 1 write to rom.
 250     c = i2c_eeprom_burstwrite(I2CEEPROM_ADDR, addr, (unsigned char *)p, sizeof(__userband_t_t));
 251     return;
 252 }
 253
 254 void format_userbands(void)
 255 {
 256    unsigned char i;
 257    for(i = 0; i < USER_BAND_NUM; i++) {
 258         userband.am_usrbands[i].start = 0x19;
 259         userband.am_usrbands[i].stop = 0x32;
 260         userband.am_usrbands[i].freq = 5600; //(0x32 - (0x32-0x19) / 2 *32) * 5
 261         userband.am_usrbands[i].mode3k = 0;
 262         //
 263         userband.fm_usrbands[i].start = 0x19;
 264         userband.fm_usrbands[i].stop = 0x32;
 265         userband.fm_usrbands[i].freq = 8600;
 266         userband.fm_usrbands[i].mode3k = 0;
 267    }
 268    save_userbands(); // Re-init
 269 }
 270
 271
 272 unsigned char load_eeprom(void)
 273 {
 274     unsigned int p[1];
 275     unsigned int sum[1];
 276     unsigned char i;
 277     unsigned char *q = (unsigned char *)(&setup);
 278     unsigned char j;
 279     unsigned int magic;
 280
 281     p[0] = 0;
 282     sum[0] = 0;
 283     // Magic word
 284     magic = readword_eeprom(p, sum);
 285     if(magic != EEPROM_INTSET_MAGIC) return 0x01; // NO MAGICWORD
 286     // amfreq
 287     for(i = 0; i < sizeof(__radioset_t); i++ ){
 288         *q = readbyte_eeprom(p, sum);
 289         q++;
 290     }
 291     magic = (eeprom_readbyte(p[0]) << 8) + eeprom_readbyte(p[0] + 1);
 292
 293     if(sum[0] != magic) return 0x00;
 294     return 0xff;
 295 }
 296
 297 /*
 298  * Check eeprom, and format/restore.
 299  */
 300 static void check_eeprom_sub(void)
 301 {
 302  _CLS();
 303  _LOCATE_0_0();
 304  printstr("Formatting...  ");
 305  format_eeprom(2,250);
 306  _LOCATE_0_0();
 307  printstr("Save defaults  ");
 308  setdefault();
 309  save_eeprom();
 310 }
 311
 312
 313 void check_eeprom(void)
 314 {
 315     unsigned char c;
 316
 317     switch(load_eeprom()) {
 318         case 0x01: // No magic-word
 319 //            idle_time_ms(2000);
 320             c = printhelp_2lines("EEPROM FORMAT", "Press any key");
 321             check_eeprom_sub();
 322             break;
 323         case 0x00: // Checksum error
 324 //           idle_time_ms(2000);
 325             c = printhelp_2lines("X-) Sum error", "Press any key");
 326             check_eeprom_sub();
 327             break;
 328         case 0xff: // Success
 329             check_frequencies();
 330             load_frequencies(setup.pagenum, 0);
 331             return;
 332             break;
 333         default: // Unknown error
 334             break;
 335     }
 336     valinit();
 337     check_frequencies();
 338     load_frequencies(setup.pagenum, 0);
 339 }