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 "akc6955.h"
  47 #include "lcd_acm1602.h"
  48 #include "ui.h"
  49 #include "eeprom.h"
  50 #include "ioports.h"
  51 #include "menu.h"
  52 #include "power.h"
  53 #include "adc_int.h"
  54
  55 void save_eeprom(void)
  56 {
  57     unsigned int p = 0;
  58     unsigned int sum = 0x0000;
  59     unsigned char i;
  60     unsigned char j;
  61     unsigned char *q;
  62
  63     // Magic word
  64     writeword_eeprom(p, &sum, 0x1298);
  65     p+= 2;
  66     // amfreq
  67     writeword_eeprom(p, &sum, amfreq);
  68     p+= 2;
  69     // amfreq
  70     writeword_eeprom(p, &sum, fmfreq);
  71     p+= 2;
  72
  73     writebyte_eeprom(p, &sum, amband);
  74     p++;
  75     writebyte_eeprom(p, &sum, fmband);
  76     p++;
  77     writebyte_eeprom(p, &sum, fm);
  78     p++;
  79     writebyte_eeprom(p, &sum, am_mode3k);
  80     p++;
  81     writebyte_eeprom(p, &sum, am_userbandnum);
  82     p++;
  83     writebyte_eeprom(p, &sum, fm_userbandnum);
  84     p++;
  85
  86 #if 0
  87     for(i = 0 ; i < USER_BAND_NUM; i++){
  88         writebyte_eeprom(p, &sum, am_usrbands[i].mode3k);
  89         writebyte_eeprom(p + 1, &sum, am_usrbands[i].start);
  90         writebyte_eeprom(p + 2, &sum, am_usrbands[i].stop);
  91         writeword_eeprom(p + 3, &sum, am_usrbands[i].freq);
  92         p += 5;
  93     }
  94     for(i = 0 ; i < USER_BAND_NUM; i++){
  95         writebyte_eeprom(p, &sum, fm_usrbands[i].mode3k);
  96         writebyte_eeprom(p + 1, &sum, fm_usrbands[i].start);
  97         writebyte_eeprom(p + 2, &sum, fm_usrbands[i].stop);
  98         writeword_eeprom(p + 3, &sum, fm_usrbands[i].freq);
  99         p += 5;
 100     }
 101 #else
 102     for(j = 0; j < USER_BAND_NUM; j++){
 103         q = (unsigned char *)&am_usrbands[j];
 104         for(i = 0; i < sizeof(_userband_t); i++){
 105             writebyte_eeprom(p, &sum, *q);
 106             p++;
 107             q++;
 108         }
 109     }
 110     for(j = 0; j < USER_BAND_NUM; j++){
 111         q = (unsigned char *)&fm_usrbands[j];
 112         for(i = 0; i < sizeof(_userband_t); i++){
 113             writebyte_eeprom(p, &sum, *q);
 114             p++;
 115             q++;
 116         }
 117     }
 118 #endif
 119     amfreq_bank[amband] = amfreq;
 120     fmfreq_bank[fmband] = fmfreq;
 121
 122     for(i = 0; i < 19; i++){
 123         writeword_eeprom(p    , &sum, amfreq_bank[i]);
 124         p += 2;
 125     }
 126     for(i = 0; i < 8; i++){
 127         writeword_eeprom(p    , &sum, fmfreq_bank[i]);
 128         p += 2;
 129     }
 130
 131     writebyte_eeprom(p, &sum, threshold_amcnr);
 132     p++;
 133     writebyte_eeprom(p, &sum, threshold_fmcnr);
 134     p++;
 135     writebyte_eeprom(p, &sum, threshold_width);
 136     p++;
 137     writebyte_eeprom(p, &sum, threshold_fmstereo);
 138     p++;
 139     writebyte_eeprom(p, &sum, lowboost);
 140     p++;
 141     writebyte_eeprom(p, &sum, stereo);
 142     p++;
 143
 144     writebyte_eeprom(p, &sum, volume);
 145     p++;
 146     writebyte_eeprom(p, &sum, prevolume);
 147     p++;
 148     writebyte_eeprom(p, &sum, fmbandwidth);
 149     p++;
 150     writeword_eeprom(p, &sum, backlight_long);
 151     p += 2;
 152     writeword_eeprom(p, &sum, ui_idlecount);
 153     p += 2;
 154
 155     // Write checksum
 156     eeprom_writebyte(p, sum >> 8);
 157     eeprom_writebyte(p + 1, sum & 0xff);
 158 }
 159
 160 unsigned char load_eeprom(void)
 161 {
 162     unsigned int p = 0;
 163     unsigned int sum = 0x0000;
 164     unsigned char i;
 165     unsigned char *q;
 166     unsigned char j;
 167     unsigned int magic;
 168
 169     // Magic word
 170     magic = readword_eeprom(p, &sum);
 171     if(magic != 0x1298) return 0x01; // NO MAGICWORD
 172     p+= 2;
 173     // amfreq
 174     amfreq = readword_eeprom(p, &sum);
 175     p+= 2;
 176     // fmfreq
 177     fmfreq = readword_eeprom(p, &sum);
 178     p+= 2;
 179
 180     amband = readbyte_eeprom(p, &sum);
 181     p++;
 182     fmband = readbyte_eeprom(p, &sum);
 183     p++;
 184     fm = readbyte_eeprom(p, &sum);
 185     p++;
 186     am_mode3k = readbyte_eeprom(p, &sum);
 187     p++;
 188     am_userbandnum = readbyte_eeprom(p, &sum);
 189     p++;
 190     fm_userbandnum = readbyte_eeprom(p, &sum);
 191     p++;
 192 #if 0
 193     for(i = 0 ; i < USER_BAND_NUM; i++){
 194         am_usrbands[i].mode3k = readbyte_eeprom(p, &sum);
 195         am_usrbands[i].start  = readbyte_eeprom(p + 1, &sum);
 196         am_usrbands[i].stop   = readbyte_eeprom(p + 2, &sum);
 197         am_usrbands[i].freq   = readword_eeprom(p + 3, &sum);
 198         p += 5;
 199     }
 200     for(i = 0 ; i < USER_BAND_NUM; i++){
 201         fm_usrbands[i].mode3k = readbyte_eeprom(p, &sum);
 202         fm_usrbands[i].start  = readbyte_eeprom(p + 1, &sum);
 203         fm_usrbands[i].stop   = readbyte_eeprom(p + 2, &sum);
 204         fm_usrbands[i].freq   = readword_eeprom(p + 3, &sum);
 205         p += 5;
 206     }
 207 #else
 208     for(j = 0; j < USER_BAND_NUM; j++){
 209         q = (unsigned char *)&am_usrbands[j];
 210         for(i = 0; i < sizeof(_userband_t); i++){
 211             *q = readbyte_eeprom(p, &sum);
 212             p++;
 213             q++;
 214         }
 215         if(am_usrbands[j].mode3k != 0){
 216             am_userband_freq[j].start = am_usrbands[j].start * 96;
 217             am_userband_freq[j].end   = am_usrbands[j].stop  * 96;
 218         } else {
 219             am_userband_freq[j].start = am_usrbands[j].start * 160;
 220             am_userband_freq[j].end   = am_usrbands[j].stop  * 160;
 221         }
 222     }
 223     for(j = 0; j < USER_BAND_NUM; j++){
 224         q = (unsigned char *)&fm_usrbands[j];
 225         for(i = 0; i < sizeof(_userband_t); i++){
 226             *q = readbyte_eeprom(p, &sum);
 227             p++;
 228             q++;
 229         }
 230         fm_userband_freq[j].start = fm_usrbands[j].start * 80 + 3000;
 231         fm_userband_freq[j].end   = fm_usrbands[j].stop * 80 + 3000;
 232     }
 233 #endif
 234     amfreq = amfreq_bank[amband];
 235     fmfreq = fmfreq_bank[fmband];
 236     for(i = 0; i < 19; i++){
 237         amfreq_bank[i] = readword_eeprom(p    , &sum);
 238         p += 2;
 239     }
 240     for(i = 0; i < 8; i++){
 241         fmfreq_bank[i] = readword_eeprom(p    , &sum);
 242         p += 2;
 243     }
 244     threshold_amcnr = readbyte_eeprom(p, &sum);
 245     p++;
 246     threshold_fmcnr = readbyte_eeprom(p, &sum);
 247     p++;
 248     threshold_width = readbyte_eeprom(p, &sum);
 249     p++;
 250     threshold_fmstereo = readbyte_eeprom(p, &sum);
 251     p++;
 252     lowboost = readbyte_eeprom(p    , &sum);
 253     p++;
 254     stereo = readbyte_eeprom(p    , &sum);
 255     p++;
 256     volume = readbyte_eeprom(p, &sum);
 257     p++;
 258     prevolume = readbyte_eeprom(p, &sum);
 259     p++;
 260     fmbandwidth = readbyte_eeprom(p, &sum);
 261     p++;
 262     backlight_long = readword_eeprom(p, &sum);
 263     p += 2;
 264     ui_idlecount = readword_eeprom(p, &sum);
 265     p += 2;
 266                                                                             // Write checksum
 267     magic = (eeprom_readbyte(p) << 8) + eeprom_readbyte(p+1);
 268
 269     if(sum != magic) return 0x00;
 270     return 0xff;
 271 }
 272
 273 /*
 274  * Check eeprom, and format/restore.
 275  */
 276 void check_eeprom(void)
 277 {
 278     unsigned char c;
 279         switch(load_eeprom()) {
 280         case 0x01: // No magic-word
 281             idle_time_ms(2000);
 282             c = printhelp_2lines("EEPROM FORMAT", "Press any key");
 283             _CLS();
 284             _LOCATE(0,0);
 285             printstr("Formatting...  ");
 286             format_eeprom(2,250);
 287             _LOCATE(0,0);
 288             printstr("Save defaults  ");
 289             setdefault();
 290             save_eeprom();
 291             break;
 292         case 0x00: // Checksum error
 293            idle_time_ms(2000);
 294             c = printhelp_2lines("X-) Sum error", "Press any key");
 295             c = pollkey_single();
 296             _CLS();
 297             _LOCATE(0,0);
 298             printstr("Formatting...");
 299             format_eeprom(2,250);
 300 //            writeword_eeprom(0, &sum, 0x1298);
 301             _LOCATE(0,0);
 302             printstr("Save defaults");
 303             setdefault();
 304             save_eeprom();
 305             break;
 306         case 0xff: // Success
 307             return;
 308             break;
 309         default: // Unknown error
 310             break;
 311     }
 312     valinit();
 313 }