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_get_data_sec(t_pffs_fd *fd) {
 126
 127         t_pffs *pffs;
 128         u8 sec,sec0,sec1;
 129
 130         pffs->fd->pffs;
 131         sec0=pffs->sec_num_data[0];
 132         sec1=pffs->sec_num_data[1];
 133
 134         for(sec=sec0;sec<sec1;sec++) {
 135                 if((addr<pffs->sec_addr[sec+1])&(addr>=pffs->sec_addr[sec])) {
 136                         fd->data_sec=sec;
 137                         break;
 138                 }
 139         }
 140
 141         return 0;
 142 }
 143
 144 int pffs_rearrange(t_pffs *pffs) {
 145
 146
 147
 148         return 0;
 149 }
 150
 151 int pffs_flash_register(t_pffs *pffs,u32 base_addr,u32 *sec_addr,u8 sec_num,
 152                         int (*fw)(u32 addr,u16 *buf,int len),
 153                         int (*fr)(u32 addr,u16 *buf,int len),
 154                         int (*fe)(u32 addr)) {
 155
 156         /* assign physical flash specs */
 157         pffs->base_addr=base_addr;
 158         pffs->sec_addr=sec_addr;
 159         pffs->sec_num=sec_num;
 160
 161         /* flash acccess function pointers */
 162         pffs->fw=fw;
 163         pffs->fr=fr;
 164         pffs->fe=fe;
 165
 166         pffs->state|=PFFS_REGISTERED;
 167
 168         return 0;
 169 }
 170
 171 int pffs_init(t_pffs *pffs) {
 172
 173         /* check whether a flash is registered */
 174         if(!(pffs->state&PFFS_REGISTERED))
 175                 return -1;
 176
 177         /* orientate */
 178         pffs_orientate(pffs);
 179
 180         return 0;
 181 }
 182
 183 int pffs_find_file(t_pffs *pffs,char *file,u32 *iaddr,u32 *daddr,u16 *len) {
 184
 185         u8 fnl;
 186         u16 data[PFFS_MAX_FILENAME_SIZE+PFFS_HEADER_SIZE];
 187
 188         *iaddr=pffs->base_addr|pffs->sec_addr[pffs->index_sec];
 189
 190         while(*iaddr<pffs->sec_addr[pffs->index_sec+1]) {
 191                 pffs->fr(*iaddr,data,3);
 192
 193                 if(!pffs_check_magic(data[0]))
 194                         break;
 195
 196                 fnl=pffs_fnlen(data[0]);
 197                 pffs->fr(*iaddr+6,data+3,fnl+fnl);
 198
 199                 if(!strncmp(file,(char *)(data+3),fnl+fnl)) {
 200                         *daddr=pffs->base_addr|((data[0]&0x000f)<<16)|data[1];
 201                         *len=data[2];
 202                         return PFFS_FILE_FOUND;
 203                 }
 204
 205                 *iaddr+=(6+fnl+fnl);
 206         }
 207
 208         return PFFS_FILE_NOT_FOUND;
 209 }
 210
 211 int pffs_open_read(t_pffs_fd *fd) {
 212
 213         int ret;
 214
 215         ret=pffs_find_file(fd->pffs,fd->file,
 216                            &(fd->iaddr),&(fd->daddr),&(fd->len));
 217
 218         if(ret==PFFS_FILE_FOUND) {
 219                 fd->dptr=fd->daddr;
 220                 fd->mode=PFFS_READ;
 221         }
 222
 223         return ret;
 224 }
 225
 226 int pffs_write_index_init(t_pffs_fd *fd) {
 227
 228         t_pffs *pffs;
 229         u16 data[PFFS_HEADER_SIZE+PFFS_MAX_FILENAME_SIZE];
 230
 231         pffs=fd->pffs;
 232         fns=fd->fn-size;
 233
 234         if(fd->iaddr+6+fns+fns>=pffs->sec_addr[pffs->index_sec+1])
 235                 return PFFS_NO_INDEX_SPACE_LEFT;
 236
 237         data[0]=0x7f00|(fns<<4)|((fd->daddr>>16)&0xf);
 238         data[1]=fd->daddr&0xffff;
 239         pffs->fw(fd->iaddr,data,4);
 240         pffs->fw(fd->iaddr+6,fd->file,fns+fns);
 241
 242         return PFFS_INDEX_WROTE_INIT;
 243 }
 244
 245 int pffs_write_finish(t_pffs_fd *fd) {
 246
 247         fd->pffs->fw(fd->iaddr+4,&(fd->len),2);
 248
 249         return 0;
 250 }
 251
 252 int pffs_open_write(t_pffs_fd *fd) {
 253
 254         int ret;
 255
 256         ret=pffs_find_file(fd->pffs,fd->file,
 257                            &(fd->iaddr),&(fd->daddr),&(fd->len));
 258
 259         switch(ret) {
 260                 case PFFS_FILE_NOT_FOUND:
 261                         ret=pffs_write_index_init();
 262                         if(ret!=PFFS_INDEX_WROTE_INIT)
 263                                 break;
 264                         fd->dptr=fd->daddr;
 265                         fd->len=0;
 266                         fd->mode=PFFS_WRITE;
 267                         break;
 268                 case PFFS_FILE_FOUND:
 269                 default:
 270                         break;
 271         }
 272
 273         return ret;
 274 }
 275
 276 int pffs_open(t_pffs *pffs,t_pffs_fd *fd,char *file,u8 mode) {
 277
 278         int ret;
 279
 280         /* the pffs struct */
 281         fd->pffs=pffs;
 282
 283         /* filename */
 284         fd->fn_size=strlen(file);
 285         if(fd->fn_size&1)
 286                 fd->file[fd->fn_size++]='\0';
 287         fd->fn_size>>1;
 288         if(fd->fn_size>PFFS_MAX_FILENAME_SIZE)
 289                 return PFFS_FILENAME_TOO_LONG;
 290         strncpy(fd->file,file,fd->fn_size+fd->fn_size);
 291
 292         /* clear fd mode */
 293         fd->mode=0;
 294
 295         /* action */
 296         switch(mode) {
 297                 case PFFS_READ:
 298                         ret=pffs_open_read(fd);
 299                         break;
 300                 case PFFS_WRITE:
 301                         ret=pffs_open_write(fd);
 302                         break;
 303                 case PFFS_RDWR:
 304                 default:
 305                         return PFFS_MODE_UNSUPPORTED;
 306         }
 307
 308         return ret;
 309 }
 310
 311 int pffs_read(t_pffs_fd *fd,u8 *buf,int len) {
 312
 313         int missing;
 314         int sec_end;
 315
 316         /* check whether valid */
 317         if(!(fd->mode&PFFS_READ))
 318                 return PFFS_EINVAL;
 319
 320         /* check len */
 321         if(len&1)
 322                 return PFFS_INVALID_LEN;
 323
 324         /* check how much we read */
 325         missing=fd->len-(fd->dptr-fd->daddr);
 326         if(len>missing)
 327                 len=missing;
 328
 329         if((fd->dptr+len)>=pffs->sec_addr[pffs->sec_num_data[1]+1])
 330                 sec_end=pffs->sec_addr[pffs->sec_num_data[1]+1]-fd->dptr;
 331
 332
 333         /* read */
 334         fd->pffs->fr(fd->dptr,(u16 *)buf,len);
 335         fd->dptr+=len;;
 336
 337         return len;
 338 }
 339
 340 int pffs_write(t_pffs_fd *fd,u8 buf,int len) {
 341
 342         /* check whether valid */
 343         if(!(fd->mode&PFFS_WRITE))
 344                 return PFFS_EINVAL;
 345
 346         /* check len */
 347         if(len&1)
 348                 return PFFS_INVALID_LEN;
 349
 350         missing=PFFS_MAX_FILE_SIZE-fd->len;
 351         if(len>missing)
 352                 len=missing;
 353
 354         /* check for  */
 355         if(fd->dptr+len>=pffs->)
 356 }
 357