betty/pffs.c

   1 /*
   2  * pffs.c - pseudo flash filesystem
   3  *
   4  * author: hackbard@hackdaworld.org
   5  *
   6  */
   7
   8 #include "pffs.h"
   9
  10 /*
  11  * functions
  12  */
  13
  14 #define pffs_check_magic(data) (((data)&PFFS_INDEX_MAGIC_MASK)==PFFS_INDEX_MAGIC)
  15 #define pffs_fnlen(data) (((data)&PFFS_FNLEN_MASK)>>4)
  16 #define pffs_daddr_msb(data) (((data)&PFFS_LEN_MSB_MASK))
  17 #define pffs_sec_erase(pffs,sec) pffs->fe(pffs->base_addr|pffs->sec_addr[sec])
  18
  19 u32 pffs_find_index(t_pffs *pffs,u8 sector) {
  20
  21         u16 data;
  22
  23         pffs->fr(pffs->base_addr+pffs->sec_addr[sector],&data,2);
  24
  25         if((data&0xf000)==PFFS_INDEX_MAGIC) {
  26                 pffs->index_sec=sector;
  27                 return PFFS_INDEX_FOUND;
  28         }
  29
  30         return PFFS_NO_INDEX_FOUND;
  31 }
  32
  33 int pffs_sec_empty(t_pffs *pffs,u8 sec) {
  34
  35         u32 addr;
  36         u16 data;
  37
  38         addr=pffs->base_addr|pffs->sec_addr[sec];
  39
  40         while(addr<(pffs->base_addr|pffs->sec_addr[sec+1])) {
  41                 pffs->fr(addr,&data,2);
  42                 if(data!=0xffff)
  43                         return PFFS_SEC_NOT_EMPTY;
  44                 addr+=2;
  45         }
  46
  47         return PFFS_SEC_EMPTY;
  48 }
  49
  50 int pffs_find_data_tmp(t_pffs *pffs,u8 sector) {
  51
  52         u32 iaddr,daddr,dend,dstart;
  53         u16 data[3];
  54         u8 fnlen;
  55
  56         iaddr=pffs->base_addr|pffs->sec_addr[pffs->index_sec];
  57         dstart=pffs->sec_addr[sector];
  58         dend=pffs->sec_addr[sector+1];
  59
  60         while(iaddr<(pffs->base_addr|pffs->sec_addr[sector+1])) {
  61                 pffs->fr(iaddr,data,6);
  62                 if(pffs_check_magic(data[0]))
  63                         break;
  64                 daddr=pffs_daddr_msb(data[0])|data[1];
  65                 if((daddr+data[2]<dstart)|(daddr>=dend)) {
  66                         fnlen=pffs_fnlen(data[0]);
  67                         iaddr+=(6+fnlen+fnlen);
  68                         continue;
  69                 }
  70                 else
  71                         return PFFS_NO_DATA_TMP;
  72         }
  73
  74         pffs->data_tmp_sec=sector;
  75         if(pffs_sec_empty(pffs,sector)!=PFFS_SEC_EMPTY)
  76                 pffs->fe(pffs->base_addr|dstart);
  77
  78         return PFFS_DATA_TMP_FOUND;;
  79 }
  80
  81 int pffs_orientate(t_pffs *pffs) {
  82
  83         u8 sec,sec0,sec1,found;
  84
  85         sec0=pffs->sec_num_index[0];
  86         sec1=pffs->sec_num_index[1];
  87
  88         found=0;
  89
  90         /* check index sectors */
  91         if(pffs_find_index(pffs,sec0)==PFFS_INDEX_FOUND)
  92                 found=1;
  93         else if(pffs_find_index(pffs,sec1)==PFFS_INDEX_FOUND)
  94                 found=1;
  95
  96         /* chose temp data sector */
  97         if(found) {
  98                 sec0=pffs->sec_num_data[0];
  99                 sec1=pffs->sec_num_data[1];
 100                 for(sec=sec1;sec>=sec0;sec--)
 101                         if(pffs_find_data_tmp(pffs,sec)==PFFS_DATA_TMP_FOUND)
 102                                 break;
 103
 104                 return PFFS_INDEX_FOUND;
 105         }
 106
 107         /* initial run => no data + no index assumed => check whether erased! */
 108         // erase index sectors
 109         if(!pffs_sec_empty(pffs,sec0))
 110                 pffs_sec_erase(pffs,sec0);
 111         if(!pffs_sec_empty(pffs,sec1))
 112                 pffs_sec_erase(pffs,sec1);
 113         pffs->index_sec=sec0;
 114         // erase data sectors
 115         sec0=pffs->sec_num_data[0];
 116         sec1=pffs->sec_num_data[1];
 117         pffs->data_tmp_sec=sec1;
 118         for(sec=sec0;sec<=sec1;sec++)
 119                 if(!pffs_sec_empty(pffs,sec))
 120                         pffs_sec_erase(pffs,sec);
 121
 122         return 0;
 123 }
 124
 125 int pffs_flash_register(t_pffs *pffs,u32 base_addr,u32 *sec_addr,
 126                         u8 sec_num_data_min,u8 sec_num_data_max,
 127                         u8 sec_num_index0,u8 sec_num_index1,
 128                         int (*fw)(u32 addr,u16 *buf,int len),
 129                         int (*fr)(u32 addr,u16 *buf,int len),
 130                         int (*fe)(u32 addr)) {
 131
 132         /* assign physical flash specs */
 133         pffs->base_addr=base_addr;
 134         pffs->sec_addr=sec_addr;
 135
 136         /* specified index and data sectors */
 137         pffs->sec_num_data[0]=sec_num_data_min;
 138         pffs->sec_num_data[1]=sec_num_data_max;
 139         pffs->sec_num_index[0]=sec_num_index0;
 140         pffs->sec_num_index[1]=sec_num_index1;
 141
 142         /* flash acccess function pointers */
 143         pffs->fw=fw;
 144         pffs->fr=fr;
 145         pffs->fe=fe;
 146
 147         pffs->state|=PFFS_REGISTERED;
 148
 149         return 0;
 150 }
 151
 152 int pffs_init(t_pffs *pffs) {
 153
 154         /* check whether a flash is registered */
 155         if(!(pffs->state&PFFS_REGISTERED))
 156                 return -1;
 157
 158         /* orientate */
 159         pffs_orientate(pffs);
 160
 161         return 0;
 162 }
 163
 164 int pffs_find_file(t_pffs *pffs,char *file,u32 *iaddr,u32 *daddr,u16 *len) {
 165
 166         u8 fnl;
 167         u16 data[PFFS_MAX_FILENAME_SIZE+PFFS_HEADER_SIZE];
 168
 169         *iaddr=pffs->base_addr|pffs->sec_addr[pffs->index_sec];
 170
 171         while(*iaddr<pffs->sec_addr[pffs->index_sec]) {
 172                 pffs->fr(*iaddr,data,3);
 173
 174                 if(!pffs_check_magic(data[0]))
 175                         break;
 176
 177                 fnl=pffs_fnlen(data[0]);
 178                 pffs->fr(*iaddr+6,data+3,fnl+fnl);
 179
 180                 if(!strncmp(file,(char *)(data+3),fnl+fnl)) {
 181                         *daddr=pffs->base_addr|((data[0]&0x000f)<<16)|data[1];
 182                         *len=data[2];
 183                         return PFFS_FILE_FOUND;
 184                 }
 185
 186                 *iaddr+=(6+fnl+fnl);
 187         }
 188
 189         return PFFS_FILE_NOT_FOUND;
 190 }
 191
 192 int pffs_open_read(t_pffs_fd *fd) {
 193
 194         int ret;
 195
 196         ret=pffs_find_file(fd->pffs,fd->file,
 197                            &(fd->iaddr),&(fd->daddr),&(fd->len));
 198
 199         if(ret==PFFS_FILE_FOUND) {
 200                 fd->dptr=fd->daddr;
 201                 fd->mode=PFFS_READ;
 202         }
 203
 204         return ret;
 205 }
 206
 207 int pffs_open_write(t_pffs_fd *fd) {
 208
 209         int ret;
 210
 211         ret=pffs_find_file(fd->pffs,fd->file,
 212                            &(fd->iaddr),&(fd->daddr),&(fd->len));
 213
 214         switch(ret) {
 215                 case PFFS_FILE_NOT_FOUND:
 216                         fd->mode=PFFS_WRITE;
 217                         pffs_write_index_init();
 218                         fd->dptr=fd->daddr;
 219                         break;
 220                 case PFFS_FILE_FOUND:
 221                 default:
 222                         break;
 223         }
 224
 225         return ret;
 226 }
 227
 228 int pffs_open(t_pffs *pffs,t_pffs_fd *fd,char *file,u8 mode) {
 229
 230         int ret;
 231
 232         /* the pffs struct */
 233         fd->pffs=pffs;
 234
 235         /* filename */
 236         fd->fn_size=strlen(file);
 237         if(fd->fn_size>PFFS_MAX_FILENAME_SIZE+PFFS_MAX_FILENAME_SIZE)
 238                 return PFFS_FILENAME_TOO_LONG;
 239         strncpy(fd->file,file,fd->fn_size);
 240         if(fd->fn_size&1)
 241                 fd->file[fd->fn_size++]='\0';
 242
 243         /* clear fd mode */
 244         fd->mode=0;
 245
 246         /* action */
 247         switch(mode) {
 248                 case PFFS_READ:
 249                         ret=pffs_open_read(fd);
 250                         break;
 251                 case PFFS_WRITE:
 252                         ret=pffs_open_write(fd);
 253                         break;
 254                 case PFFS_RDWR:
 255                 default:
 256                         return PFFS_MODE_UNSUPPORTED;
 257         }
 258
 259         return ret;
 260 }
 261
 262 int pffs_read(t_pffs_fd *fd,u8 *buf,int len) {
 263
 264         int missing;
 265
 266         /* check whether valid */
 267         if(!(fd->mode&PFFS_READ))
 268                 return PFFS_EINVAL;
 269
 270         /* checl len */
 271         if(len&1)
 272                 return PFFS_INVALID_LEN;
 273
 274         missing=fd->len-(fd->dptr-fd->daddr);
 275         if(len>missing)
 276                 len=missing;
 277
 278         /* read */
 279         fd->pffs->fr(fd->dptr,(u16 *)buf,len);
 280         fd->dptr+=len;;
 281
 282         return len;
 283 }
 284