kernel/drivers/block/floppy.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   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 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <config.h>
  23 #include <build.h>
  24
  25 #ifdef ARCH_i386
  26 #include <system.h>
  27 #include <arch/io.h>
  28 #include <string.h>
  29 #include <dev.h>
  30 #include <vfs.h>
  31 #include <partition.h>
  32
  33 #define MAX_DISKCHANGE  16
  34
  35 /* FDC_H */
  36 /* globals */
  37 static volatile bool done = false;
  38 static bool dchange = false;
  39 static bool motor = false;
  40 static int mtick = 0;
  41 static volatile int tmout = 0;
  42 static char status[7] = { 0 };
  43 static char statsz = 0;
  44 static char sr0 = 0;
  45 static char fdc_track = 0xff;
  46 static unsigned fdc_diskchange = 0;
  47 static DrvGeom geometry = { DG144_HEADS, DG144_TRACKS, DG144_SPT };
  48
  49 unsigned char *floppy_tbaddr;    /* physical address of track buffer */
  50
  51 /* prototypes */
  52 void sendbyte (int byte);
  53 int getbyte ();
  54 void floppy_handler (void *r);
  55 bool waitfdc (bool sensei);
  56 bool fdc_rw (int block, char *blockbuff, bool read, unsigned long nosectors);
  57
  58 static char *drive_type[6] = { "no floppy drive",
  59                         "360kb 5.25in floppy drive",
  60                         "1.2mb 5.25in floppy drive",
  61                         "720kb3.5in", "1.44mb 3.5in",
  62                         "2.88mb 3.5in" };
  63
  64 /* helper functions */
  65
  66 unsigned int floppy_detect (void)
  67 {
  68         unsigned char c;
  69         int a,b;
  70         outb (0x70, 0x10);
  71         c = inb (0x71);
  72         a = c >> 4;
  73         b = c & 0xF;
  74
  75         if (!a)
  76                 return 0;
  77
  78         kprintf ("floppy drive /dev/fd0: %s\n", drive_type[a]);
  79
  80         if (b)  // if floppy drive not exist, dont write this
  81                 kprintf ("floppy drive /dev/fd1: %s\n", drive_type[b]);
  82
  83         return 1;
  84 }
  85
  86
  87 /* This is the IRQ6 handler */
  88 void floppy_handler (void *r)
  89 {
  90         /* signal operation finished */
  91         done = true;
  92         /* EOI the PIC */
  93         //outb (0x20,0x20);
  94 }
  95
  96 /* init driver */
  97 unsigned int floppy_install (void)
  98 {
  99         irq_install_handler (6, (void *) floppy_handler);
 100
 101         return 1;
 102 }
 103
 104 unsigned int init_floppy (void)
 105 {
 106         int i;
 107
 108         /* allocate track buffer (must be located below 1M) */
 109         /* see above for address assignment, floppy  buffer is at floppy_tbaddr) */
 110         /* install IRQ6 handler */
 111
 112         done = false;
 113
 114         reset ();
 115
 116         /* get floppy controller version */
 117         sendbyte (CMD_VERSION);
 118         i = getbyte ();
 119
 120         if (i == 0x80)
 121                 kprintf ("NEC765 controller found\n");
 122         else
 123                 kprintf ("Enhanced controller found\n");
 124
 125         /* spin up the disk */
 126         //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|MOTORON");
 127         //motoron ();
 128
 129         floppy_tbaddr = (unsigned char *) kmalloc (1024);
 130
 131         return 1;
 132 }
 133
 134 /* sendbyte() routine from intel manual */
 135 void sendbyte (int byte)
 136 {
 137         volatile int msr;
 138         int tmo;
 139
 140         for (tmo = 0; tmo < 128; tmo ++) {
 141                 msr = inb (FDC_MSR);
 142
 143                 if ((msr & 0xc0) == 0x80) {
 144                         outb (FDC_DATA, byte);
 145                         return;
 146                 }
 147
 148                 inb (0x80);   /* delay */
 149         }
 150 }
 151
 152 /* getbyte() routine from intel manual */
 153 int getbyte ()
 154 {
 155         volatile int msr;
 156         int tmo;
 157
 158         for (tmo = 0; tmo < 128; tmo ++) {
 159                 msr = inb (FDC_MSR);
 160
 161                 if ((msr & 0xd0) == 0xd0)
 162                         return inb (FDC_DATA);
 163
 164                 inb (0x80);   /* delay */
 165         }
 166         return -1;   /* read timeout */
 167 }
 168
 169 /* this waits for FDC command to complete */
 170 bool waitfdc (bool sensei)
 171 {
 172         tmout = 80000;
 173         /* wait for IRQ6 handler to signal command finished */
 174 /*      while (!done && tmout) {
 175                 schedule ();
 176                 tmout --;
 177                 delay (10);
 178         }*/
 179
 180         while (!done && tmout) {
 181                 kprintf("");
 182                 schedule ();
 183         }
 184
 185         /* read in command result bytes */
 186         statsz = 0;
 187
 188         while ((statsz < 7) && (inb(FDC_MSR) & 0x10)) {
 189                 status[statsz ++] = getbyte ();
 190         }
 191
 192         if (sensei) {
 193                 /* send a "sense interrupt status" command */
 194                 sendbyte (CMD_SENSEI);
 195                 sr0 = getbyte ();
 196                 fdc_track = getbyte ();
 197         }
 198
 199         done = false;
 200 /*
 201         if (!tmout)
 202         {
 203                 if (inb(FDC_DIR) & 0x80)
 204                         dchange = true;
 205                 return false;
 206         }
 207         else*/
 208                 return true;
 209 }
 210
 211
 212
 213 /* This is the timer (int 1ch) handler */
 214 void int1c (void)
 215 {
 216         if (tmout)
 217                 -- tmout;     /* bump timeout */
 218
 219         if (mtick > 0)
 220                 -- mtick;
 221         else if (!mtick && motor) {
 222                 outb (FDC_DOR, 0x0c);  /* turn off floppy motor */
 223                 motor = false;
 224         }
 225 }
 226
 227 /*
 228  * converts linear block address to head/track/sector
 229  *
 230  * blocks are numbered 0..heads*tracks*spt-1
 231  * blocks 0..spt-1 are serviced by head #0
 232  * blocks spt..spt*2-1 are serviced by head 1
 233  *
 234  * WARNING: garbage in == garbage out
 235  */
 236 void block2hts (int block,int *head,int *track,int *sector)
 237 {
 238         *head = (block % (geometry.spt * geometry.heads)) / (geometry.spt);
 239         *track = block / (geometry.spt * geometry.heads);
 240         *sector = block % geometry.spt + 1;
 241 }
 242
 243 /**** disk operations ****/
 244
 245 /* this gets the FDC to a known state */
 246 void reset (void)
 247 {
 248         /* stop the motor and disable IRQ */
 249         motoroff ();
 250         outb (FDC_DOR, 0);
 251         mtick = 0;
 252         motor = false;
 253
 254         /* program data rate (500K/s) */
 255         outb (FDC_DRS, 0);
 256
 257         /* re-enable interrupts */
 258         outb (FDC_DOR, 0x0c);
 259
 260         /* resetting triggered an interrupt - handle it */
 261         done = true;
 262         waitfdc (true);
 263         done = true;
 264         waitfdc (true);
 265         done = true;
 266         waitfdc (true);
 267         done = true;
 268         waitfdc (true);
 269
 270         /* specify drive timings (got these off the BIOS) */
 271         sendbyte (CMD_SPECIFY);
 272         sendbyte (0xdf);  /* SRT = 3ms, HUT = 240ms */
 273         sendbyte (0x02);  /* HLT = 16ms, ND = 0 */
 274
 275         /* clear "disk change" status */
 276         //printf("RESET|SEEK\n");
 277         seek (5);
 278
 279         recalibrate ();
 280
 281         dchange = false;
 282 }
 283
 284 /* this returns whether there was a disk change */
 285 bool diskchange (void)
 286 {
 287         return dchange;
 288 }
 289
 290 /* this turns the motor on */
 291 void motoron (void)
 292 {
 293         if (!motor) {
 294                 mtick = -1;     /* stop motor kill countdown */
 295                 outb (FDC_DOR, 0x1c);
 296
 297                 delay (100); /* delay 500ms for motor to spin up */
 298                 motor = true;
 299         }
 300 }
 301
 302 /* this turns the motor off */
 303 void motoroff (void)
 304 {
 305         if (motor) {
 306 //              mtick = 13500;   /* start motor kill countdown: 36 ticks ~ 2s */
 307
 308                 outb (FDC_DOR, 0x0c);
 309                 outb (0x3f2, 0);
 310                 motor = false;
 311                 delay (200);
 312         }
 313 }
 314
 315 /* recalibrate the drive */
 316 void recalibrate (void)
 317 {
 318         /* turn the motor on */
 319         //motoron();
 320
 321         /* send actual command bytes */
 322         sendbyte (CMD_RECAL);
 323         sendbyte (0);
 324         /* wait until seek finished */
 325         waitfdc (true);
 326
 327 /* turn the motor off */
 328         //motoroff();
 329
 330 }
 331
 332 /* seek to track */
 333 bool seek (int track)
 334 {
 335
 336         if (fdc_track == track)  /* already there? */
 337                 return true;
 338
 339         //motoron();
 340         /* send actual command bytes */
 341         sendbyte (CMD_SEEK);
 342         sendbyte (0);
 343         sendbyte (track);
 344
 345         /* wait until seek finished */
 346         if (!waitfdc (true)) {
 347                 DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | SEEK | TIMEOUT");
 348                 return false;     /* timeout! */
 349         }
 350         /* now let head settle for 15ms */
 351         delay (20);
 352         //motoroff();
 353         /* check that seek worked */
 354         if ((sr0 != 0x20) || (fdc_track != track)) {
 355                 if (sr0 != 0x20)
 356                         DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | SEEK | SR0!=0x20");
 357
 358                 if (fdc_track != track)
 359                         DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | SEEK | FDC_TRACK!=TRACK");
 360
 361                 return false;
 362         }
 363         else
 364                 return true;
 365 }
 366
 367 /* checks drive geometry - call this after any disk change */
 368 bool log_disk (DrvGeom *g)
 369 {
 370         /* get drive in a known status before we do anything */
 371         reset();
 372
 373         /* assume disk is 1.68M and try and read block #21 on first track */
 374         geometry.heads = DG168_HEADS;
 375         geometry.tracks = DG168_TRACKS;
 376         geometry.spt = DG168_SPT;
 377
 378         if (read_block (20, NULL, 1)) {
 379                 /* disk is a 1.68M disk */
 380                 if (g) {
 381                         g->heads = geometry.heads;
 382                         g->tracks = geometry.tracks;
 383                         g->spt = geometry.spt;
 384                 }
 385
 386                 return true;
 387         }
 388
 389         /* OK, not 1.68M - try again for 1.44M reading block #18 on first track */
 390         geometry.heads = DG144_HEADS;
 391         geometry.tracks = DG144_TRACKS;
 392         geometry.spt = DG144_SPT;
 393
 394         if (read_block (17, NULL, 1)) {
 395                 /* disk is a 1.44M disk */
 396                 if (g) {
 397                         g->heads = geometry.heads;
 398                         g->tracks = geometry.tracks;
 399                         g->spt = geometry.spt;
 400                 }
 401
 402                 return true;
 403         }
 404
 405         /* it's not 1.44M or 1.68M - we don't support it */
 406         return false;
 407 }
 408
 409 /* read block (blockbuff is 512 byte buffer) */
 410 bool read_block (int block, char *blockbuff, unsigned long nosectors)
 411 {
 412         int track = 0, sector = 0, head = 0, track2 = 0, result = 0, loop = 0;
 413
 414         reset ();
 415
 416         //The FDC can read multiple sides at once but not multiple tracks
 417         //printf("READ 1\n");
 418         block2hts (block, &head, &track, &sector);
 419         block2hts (block+nosectors, &head, &track2, &sector);
 420
 421         if(track != track2) {
 422                 for(loop = 0; (unsigned) loop < nosectors; loop ++)
 423                         result = fdc_rw (block+loop, blockbuff + (loop*512), true, 1);
 424
 425                 return result;
 426         }
 427 //      printf("FDC_RW\n");
 428         return fdc_rw (block, blockbuff, true, nosectors);
 429 }
 430
 431 /* write block (blockbuff is 512 byte buffer) */
 432 bool write_block (int block, char *blockbuff, unsigned long nosectors)
 433 {
 434         return fdc_rw (block, blockbuff, false, nosectors);
 435 }
 436
 437 /*
 438  * since reads and writes differ only by a few lines, this handles both.  This
 439  * function is called by read_block() and write_block()
 440  */
 441 bool fdc_rw (int block, char *blockbuff, bool read, unsigned long nosectors)
 442 {
 443         int head,track,sector,tries, copycount = 0;
 444         unsigned char *p_tbaddr = (unsigned char *) floppy_tbaddr;
 445         unsigned char *p_blockbuff = blockbuff;
 446
 447         /* convert logical address into physical address */
 448         block2hts (block, &head, &track, &sector);
 449
 450         /* spin up the disk */
 451         //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|MOTORON");
 452         motoron();
 453
 454         if (!read && blockbuff) {
 455                 /* copy data from data buffer into track buffer */
 456                 for (copycount = 0; (unsigned) copycount < (nosectors*512); copycount ++) {
 457                         *p_tbaddr = *p_blockbuff;
 458                         p_blockbuff++;
 459                         p_tbaddr++;
 460                 }
 461         }
 462
 463         //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|COPY1");
 464
 465         for (tries = 0; tries < 3; tries ++) {
 466
 467                 //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|RIGHT");
 468                 /* move head to right track */
 469                 if (!seek (track)) {
 470                         motoroff ();
 471                         DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | CANNOT SEEK\n");
 472                         return false;
 473                 }
 474
 475                 /* check for diskchange */
 476                 //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|DISKCHANGE");
 477
 478                 if (inb (FDC_DIR) & 0x80) {
 479                         dchange = true;
 480                         seek (1);  /* clear "disk change" status */
 481                         recalibrate ();
 482                         motoroff ();
 483                         /*fdc_diskchange ++;
 484                         DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | DISK CHANGE STATUS => repeat");
 485                         if (fdc_diskchange < MAX_DISKCHANGE)*/
 486                         return fdc_rw (block, blockbuff, read, nosectors);
 487
 488                         /*printf ("Floppy disk not response, resetting drive..\n");
 489                         reset ();
 490                         motoroff();
 491                         return false;*/
 492                 }
 493                 //fdc_diskchange = 0;
 494
 495                 //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|RATE");
 496
 497                 /* program data rate (500K/s) */
 498                 outb (FDC_CCR, 0);
 499
 500                 /* send command */
 501                 if (read) {
 502                         //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|DMA");
 503                         dma_xfer (2, (unsigned long) floppy_tbaddr, nosectors * 512, false);
 504                         sendbyte (CMD_READ);
 505                 } else {
 506                         dma_xfer (2, (unsigned long) floppy_tbaddr, nosectors * 512, true);
 507                         sendbyte (CMD_WRITE);
 508                 }
 509
 510                 sendbyte (head << 2);
 511                 sendbyte (track);
 512                 sendbyte (head);
 513                 sendbyte (sector);
 514                 sendbyte (2);               /* 512 bytes/sector */
 515                 sendbyte (geometry.spt);
 516
 517                 if (geometry.spt == DG144_SPT)
 518                         sendbyte (DG144_GAP3RW);  /* gap 3 size for 1.44M read/write */
 519                 else
 520                         sendbyte (DG168_GAP3RW);  /* gap 3 size for 1.68M read/write */
 521
 522                 sendbyte (0xff);            /* DTL = unused */
 523
 524                 //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|STEP1");
 525                 /* wait for command completion */
 526                 /* read/write don't need "sense interrupt status" */
 527                 if (!waitfdc(1)) {
 528                         kprintf ("Timed out, trying operation again after reset()\n");
 529                         reset ();
 530                         return fdc_rw (block, blockbuff, read, nosectors);
 531                 }
 532
 533                 //DPRINT (DBG_DRIVER | DBG_BLOCK, "FDC_RW|%d",(status[0] & 0xc0));
 534
 535                 if ((status[0] & 0xc0) == 0)
 536                         break;   /* worked! outta here! */
 537
 538                 if (tries)
 539                         DPRINT (DBG_DRIVER | DBG_BLOCK, "Try %d error => read from floppy\n", tries);
 540
 541                 recalibrate ();  /* oops, try again... */
 542         }
 543
 544
 545         /* stop the motor */
 546         //printf("FDC_RW|MOTOROFF\n");
 547         motoroff ();
 548
 549         if (read && blockbuff) {
 550                 /* copy data from track buffer into data buffer */
 551                 //printf("FDC_RW|OK\n");
 552                 p_blockbuff = blockbuff;
 553                 p_tbaddr = (unsigned char *) floppy_tbaddr;
 554
 555                 for (copycount = 0; (unsigned) copycount < (nosectors * 512); copycount ++) {
 556                         *p_blockbuff = *p_tbaddr;
 557                         p_blockbuff ++;
 558                         p_tbaddr ++;
 559                 }
 560         } else
 561                 DPRINT (DBG_DRIVER | DBG_BLOCK, "FLOPPY | ERROR\n");
 562
 563         return (tries != 3);
 564 }
 565
 566 /* this formats a track, given a certain geometry */
 567 bool format_track (char track, DrvGeom *g)
 568 {
 569         int i, h, r, r_id, split;
 570         char tmpbuff[256];
 571         unsigned char *p_tbaddr = (unsigned char *) floppy_tbaddr;
 572         unsigned int copycount = 0;
 573
 574         /* check geometry */
 575         if (g->spt != DG144_SPT && g->spt != DG168_SPT)
 576                 return false;
 577
 578         /* spin up the disk */
 579         motoron ();
 580
 581         /* program data rate (500K/s) */
 582         outb (FDC_CCR, 0);
 583
 584         seek (track);  /* seek to track */
 585
 586         /* precalc some constants for interleave calculation */
 587         split = g->spt / 2;
 588
 589         if (g->spt & 1)
 590                 split ++;
 591
 592         for (h = 0; h < g->heads; h ++) {
 593                 /* for each head... */
 594                 /* check for diskchange */
 595                 if (inb (FDC_DIR) & 0x80) {
 596                         dchange = true;
 597                         seek (1);  /* clear "disk change" status */
 598                         recalibrate ();
 599                         motoroff ();
 600
 601                         return false;
 602                 }
 603
 604                 i = 0;   /* reset buffer index */
 605                 for (r = 0; r < g->spt; r++) {
 606                         /* for each sector... */
 607
 608                         /* calculate 1:2 interleave (seems optimal in my system) */
 609                         r_id = r / 2 + 1;
 610
 611                         if (r & 1)
 612                                 r_id += split;
 613
 614                         /* add some head skew (2 sectors should be enough) */
 615                         if (h & 1) {
 616                                 r_id -= 2;
 617
 618                                 if (r_id < 1)
 619                                         r_id += g->spt;
 620                         }
 621                         /* add some track skew (1/2 a revolution) */
 622                         if (track & 1) {
 623                                 r_id -= g->spt / 2;
 624
 625                                 if (r_id < 1)
 626                                         r_id += g->spt;
 627                         }
 628
 629                         /**** interleave now calculated - sector ID is stored in r_id ****/
 630
 631                         /* fill in sector ID's */
 632                         tmpbuff[i ++] = track;
 633                         tmpbuff[i ++] = h;
 634                         tmpbuff[i ++] = r_id;
 635                         tmpbuff[i ++] = 2;
 636                 }
 637
 638                 /* copy sector ID's to track buffer */
 639                 for (copycount = 0; copycount < (unsigned) i; copycount ++) {
 640                         *p_tbaddr = tmpbuff[copycount];
 641                         p_tbaddr ++;
 642                 }
 643                 //movedata(_my_ds(),(long)tmpbuff,_dos_ds,tbaddr,i);
 644
 645                 /* start dma xfer */
 646                 dma_xfer (2, (unsigned long) floppy_tbaddr, i, true);
 647
 648                 /* prepare "format track" command */
 649                 sendbyte (CMD_FORMAT);
 650                 sendbyte (h << 2);
 651                 sendbyte (2);
 652                 sendbyte (g->spt);
 653
 654                 if (g->spt == DG144_SPT)
 655                         sendbyte (DG144_GAP3FMT);    /* gap3 size for 1.44M format */
 656                 else
 657                         sendbyte (DG168_GAP3FMT);    /* gap3 size for 1.68M format */
 658
 659                 sendbyte (0);     /* filler byte */
 660
 661                 /* wait for command to finish */
 662                 if (!waitfdc (false))
 663                         return false;
 664
 665                 if (status[0] & 0xc0) {
 666                         motoroff ();
 667                         return false;
 668                 }
 669         }
 670
 671         motoroff ();
 672
 673         return true;
 674 }
 675
 676
 677
 678 bool floppy_acthandler (unsigned act, partition_t *p, char *block, char *more, int n)
 679 {
 680         switch (act) {
 681                 case DEV_ACT_INIT:
 682                 {
 683                         if (!floppy_detect ())
 684                                 return 0;
 685
 686                         int_disable ();
 687                         floppy_install ();
 688                         int_enable ();
 689                         init_floppy ();
 690
 691                         return 1;
 692                 }
 693                 break;
 694                 case DEV_ACT_READ:
 695                 {
 696                         read_block (n, block, 1);
 697                         return 1;
 698                 }
 699                 break;
 700                 case DEV_ACT_MOUNT:
 701                 {
 702                         int f = 0, t = 0;
 703                         if (!read_dir (-1))
 704                                 return 0;
 705
 706                         if (strlen (more)) {
 707                                 if (!strcmp (more, "."))
 708                                         return read_dir (0);
 709
 710                                 if (!strcmp (more, ".."))
 711                                         return read_dir (1);
 712
 713                                 while (strlen (dir[f].name)) {
 714                                         if (!strncmp (dir[f].name, more, strlen (more))) {
 715                                                 if (!read_dir (f))
 716                                                         return 0;
 717
 718                                                 t = 1;
 719                                                 break;
 720                                         }
 721
 722                                         f ++;
 723                                 }
 724
 725                                 if (!t)
 726                                         return 0;
 727                         }
 728
 729                         f = 0;
 730                         unsigned fl = strlen (dir[f].name);
 731
 732                          while (fl) {
 733                                 unsigned attrib = VFS_FILEATTR_MOUNTED;
 734
 735 /*
 736                                 #define VFS_FILEATTR_FILE       0x1
 737                                 #define VFS_FILEATTR_DIR        0x2
 738                                 #define VFS_FILEATTR_HIDDEN     0x4
 739                                 #define VFS_FILEATTR_SYSTEM     0x8
 740                                 #define VFS_FILEATTR_BIN        0x10
 741                                 #define VFS_FILEATTR_READ       0x20
 742                                 #define VFS_FILEATTR_WRITE      0x40
 743
 744                                 case 0: dir[y].read=1; break;
 745                                 case 1: dir[y].hidden=1; break;
 746                                 case 2: dir[y].system=1; break;
 747                                 case 3: dir[y].volume=1; break;
 748                                 case 4: dir[y].dir=1; break;
 749                                 case 5: dir[y].bin=1; break;
 750 */
 751
 752                                 if (dir[f].read) {
 753                                         attrib |= VFS_FILEATTR_READ;
 754                                         attrib |= VFS_FILEATTR_WRITE;
 755                                 }
 756                                 if (dir[f].hidden)
 757                                         attrib |= VFS_FILEATTR_HIDDEN;
 758                                 if (dir[f].system)
 759                                         attrib |= VFS_FILEATTR_SYSTEM;
 760                                 if (dir[f].dir)
 761                                         attrib |= VFS_FILEATTR_DIR;
 762                                 else
 763                                         attrib |= VFS_FILEATTR_FILE;
 764                                 if (dir[f].bin)
 765                                         attrib |= VFS_FILEATTR_BIN;
 766
 767                                 dir[f].name[10] = '\0';
 768                                 vfs_list_add (dir[f].name, attrib, block);
 769                                 //printf ("add: %s to %s\n", dir[f].name, block);
 770
 771                                 f ++;
 772                                 fl = strlen (dir[f].name);
 773                         }
 774
 775                         return 1;
 776                 }
 777                 break;
 778         }
 779
 780         return 0;
 781 }
 782 #endif