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);
 132     p++;
 133     writebyte_eeprom(p, &sum, lowboost);
 134     p++;
 135     writebyte_eeprom(p, &sum, stereo);
 136     p++;
 137
 138     writebyte_eeprom(p, &sum, volume);
 139     p++;
 140     writebyte_eeprom(p, &sum, prevolume);
 141     p++;
 142     writebyte_eeprom(p, &sum, fmbandwidth);
 143     p++;
 144     writeword_eeprom(p, &sum, backlight_long);
 145     p += 2;
 146     writeword_eeprom(p, &sum, ui_idlecount);
 147     p += 2;
 148
 149     // Write checksum
 150     eeprom_writebyte(p, sum >> 8);
 151     eeprom_writebyte(p + 1, sum & 0xff);
 152 }
 153
 154 unsigned char load_eeprom(void)
 155 {
 156     unsigned int p = 0;
 157     unsigned int sum = 0x0000;
 158     unsigned char i;
 159     unsigned char *q;
 160     unsigned char j;
 161     unsigned int magic;
 162
 163     // Magic word
 164     magic = readword_eeprom(p, &sum);
 165     if(magic != 0x1298) return 0x01; // NO MAGICWORD
 166     p+= 2;
 167     // amfreq
 168     amfreq = readword_eeprom(p, &sum);
 169     p+= 2;
 170     // fmfreq
 171     fmfreq = readword_eeprom(p, &sum);
 172     p+= 2;
 173
 174     amband = readbyte_eeprom(p, &sum);
 175     p++;
 176     fmband = readbyte_eeprom(p, &sum);
 177     p++;
 178     fm = readbyte_eeprom(p, &sum);
 179     p++;
 180     am_mode3k = readbyte_eeprom(p, &sum);
 181     p++;
 182     am_userbandnum = readbyte_eeprom(p, &sum);
 183     p++;
 184     fm_userbandnum = readbyte_eeprom(p, &sum);
 185     p++;
 186 #if 0
 187     for(i = 0 ; i < USER_BAND_NUM; i++){
 188         am_usrbands[i].mode3k = readbyte_eeprom(p, &sum);
 189         am_usrbands[i].start  = readbyte_eeprom(p + 1, &sum);
 190         am_usrbands[i].stop   = readbyte_eeprom(p + 2, &sum);
 191         am_usrbands[i].freq   = readword_eeprom(p + 3, &sum);
 192         p += 5;
 193     }
 194     for(i = 0 ; i < USER_BAND_NUM; i++){
 195         fm_usrbands[i].mode3k = readbyte_eeprom(p, &sum);
 196         fm_usrbands[i].start  = readbyte_eeprom(p + 1, &sum);
 197         fm_usrbands[i].stop   = readbyte_eeprom(p + 2, &sum);
 198         fm_usrbands[i].freq   = readword_eeprom(p + 3, &sum);
 199         p += 5;
 200     }
 201 #else
 202     for(j = 0; j < USER_BAND_NUM; j++){
 203         q = (unsigned char *)&am_usrbands[j];
 204         for(i = 0; i < sizeof(_userband_t); i++){
 205             *q = readbyte_eeprom(p, &sum);
 206             p++;
 207             q++;
 208         }
 209         if(am_usrbands[j].mode3k != 0){
 210             am_userband_freq[j].start = am_usrbands[j].start * 96;
 211             am_userband_freq[j].end   = am_usrbands[j].stop  * 96;
 212         } else {
 213             am_userband_freq[j].start = am_usrbands[j].start * 160;
 214             am_userband_freq[j].end   = am_usrbands[j].stop  * 160;
 215         }
 216     }
 217     for(j = 0; j < USER_BAND_NUM; j++){
 218         q = (unsigned char *)&fm_usrbands[j];
 219         for(i = 0; i < sizeof(_userband_t); i++){
 220             *q = readbyte_eeprom(p, &sum);
 221             p++;
 222             q++;
 223         }
 224         fm_userband_freq[j].start = fm_usrbands[j].start * 80 + 3000;
 225         fm_userband_freq[j].end   = fm_usrbands[j].stop * 80 + 3000;
 226     }
 227 #endif
 228     amfreq = amfreq_bank[amband];
 229     fmfreq = fmfreq_bank[fmband];
 230     for(i = 0; i < 19; i++){
 231         amfreq_bank[i] = readword_eeprom(p    , &sum);
 232         p += 2;
 233     }
 234     for(i = 0; i < 8; i++){
 235         fmfreq_bank[i] = readword_eeprom(p    , &sum);
 236         p += 2;
 237     }
 238     threshold = readbyte_eeprom(p    , &sum);
 239     p++;
 240     lowboost = readbyte_eeprom(p    , &sum);
 241     p++;
 242     stereo = readbyte_eeprom(p    , &sum);
 243     p++;
 244     volume = readbyte_eeprom(p, &sum);
 245     p++;
 246     prevolume = readbyte_eeprom(p, &sum);
 247     p++;
 248     fmbandwidth = readbyte_eeprom(p, &sum);
 249     p++;
 250     backlight_long = readword_eeprom(p, &sum);
 251     p += 2;
 252     ui_idlecount = readword_eeprom(p, &sum);
 253     p += 2;
 254                                                                             // Write checksum
 255     magic = (eeprom_readbyte(p) << 8) + eeprom_readbyte(p+1);
 256
 257     if(sum != magic) return 0x00;
 258     return 0xff;
 259 }
 260
 261 /*
 262  * Check eeprom, and format/restore.
 263  */
 264 void check_eeprom(void)
 265 {
 266     unsigned char c;
 267         switch(load_eeprom()) {
 268         case 0x01: // No magic-word
 269             idle_time_ms(2000);
 270             c = printhelp_2lines("EEPROM FORMAT", "Press any key");
 271             _CLS();
 272             _LOCATE(0,0);
 273             printstr("Formatting...  ");
 274             format_eeprom(2,250);
 275             _LOCATE(0,0);
 276             printstr("Save defaults  ");
 277             setdefault();
 278             save_eeprom();
 279             break;
 280         case 0x00: // Checksum error
 281            idle_time_ms(2000);
 282             c = printhelp_2lines("X-) Sum error", "Press any key");
 283             c = pollkey_single();
 284             _CLS();
 285             _LOCATE(0,0);
 286             printstr("Formatting...");
 287             format_eeprom(2,250);
 288 //            writeword_eeprom(0, &sum, 0x1298);
 289             _LOCATE(0,0);
 290             printstr("Save defaults");
 291             setdefault();
 292             save_eeprom();
 293             break;
 294         case 0xff: // Success
 295             return;
 296             break;
 297         default: // Unknown error
 298             break;
 299     }
 300     valinit();
 301 }