firmware/common/disk.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Björn Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdio.h>
  22 #include "storage.h"
  23 #include "debug.h"
  24 #include "fat.h"
  25 #ifdef HAVE_HOTSWAP
  26 #include "hotswap.h"
  27 #include "dir.h" /* for release_dirs() */
  28 #include "file.h" /* for release_files() */
  29 #endif
  30 #include "disk.h"
  31 #include <string.h>
  32
  33 /* Partition table entry layout:
  34    -----------------------
  35    0: 0x80 - active
  36    1: starting head
  37    2: starting sector
  38    3: starting cylinder
  39    4: partition type
  40    5: end head
  41    6: end sector
  42    7: end cylinder
  43    8-11: starting sector (LBA)
  44    12-15: nr of sectors in partition
  45 */
  46
  47 #define BYTES2INT32(array,pos)                                  \
  48     ((long)array[pos] | ((long)array[pos+1] << 8 ) |            \
  49      ((long)array[pos+2] << 16 ) | ((long)array[pos+3] << 24 ))
  50
  51 static const unsigned char fat_partition_types[] = {
  52     0x0b, 0x1b, /* FAT32 + hidden variant */
  53     0x0c, 0x1c, /* FAT32 (LBA) + hidden variant */
  54 #ifdef HAVE_FAT16SUPPORT
  55     0x04, 0x14, /* FAT16 <= 32MB + hidden variant */
  56     0x06, 0x16, /* FAT16  > 32MB + hidden variant */
  57     0x0e, 0x1e, /* FAT16 (LBA) + hidden variant */
  58 #endif
  59 };
  60
  61 static struct partinfo part[8]; /* space for 4 partitions on 2 drives */
  62 static int vol_drive[NUM_VOLUMES]; /* mounted to which drive (-1 if none) */
  63
  64 #ifdef MAX_LOG_SECTOR_SIZE
  65 int disk_sector_multiplier = 1;
  66 #endif
  67
  68 struct partinfo* disk_init(IF_MV_NONVOID(int drive))
  69 {
  70     int i;
  71     unsigned char sector[512];
  72 #ifdef HAVE_MULTIVOLUME
  73     /* For each drive, start at a different position, in order not to destroy
  74        the first entry of drive 0.
  75        That one is needed to calculate config sector position. */
  76     struct partinfo* pinfo = &part[drive*4];
  77     if ((size_t)drive >= sizeof(part)/sizeof(*part)/4)
  78         return NULL; /* out of space in table */
  79 #else
  80     struct partinfo* pinfo = part;
  81     const int drive = 0;
  82     (void)drive;
  83 #endif
  84
  85     storage_read_sectors(drive, 0,1, &sector);
  86     /* check that the boot sector is initialized */
  87     if ( (sector[510] != 0x55) ||
  88          (sector[511] != 0xaa)) {
  89         DEBUGF("Bad boot sector signature\n");
  90         return NULL;
  91     }
  92
  93     /* parse partitions */
  94     for ( i=0; i<4; i++ ) {
  95         unsigned char* ptr = sector + 0x1be + 16*i;
  96         pinfo[i].type  = ptr[4];
  97         pinfo[i].start = BYTES2INT32(ptr, 8);
  98         pinfo[i].size  = BYTES2INT32(ptr, 12);
  99
 100         DEBUGF("Part%d: Type %02x, start: %08lx size: %08lx\n",
 101                i,pinfo[i].type,pinfo[i].start,pinfo[i].size);
 102
 103         /* extended? */
 104         if ( pinfo[i].type == 5 ) {
 105             /* not handled yet */
 106         }
 107     }
 108     return pinfo;
 109 }
 110
 111 struct partinfo* disk_partinfo(int partition)
 112 {
 113     return &part[partition];
 114 }
 115
 116 int disk_mount_all(void)
 117 {
 118     int mounted;
 119     int i;
 120
 121 #ifdef HAVE_HOTSWAP
 122     card_enable_monitoring(false);
 123 #endif
 124
 125     fat_init(); /* reset all mounted partitions */
 126     for (i=0; i<NUM_VOLUMES; i++)
 127         vol_drive[i] = -1; /* mark all as unassigned */
 128
 129     mounted = disk_mount(0);
 130 #ifdef HAVE_HOTSWAP
 131     if (card_detect())
 132     {
 133         mounted += disk_mount(1); /* try 2nd "drive", too */
 134     }
 135
 136     card_enable_monitoring(true);
 137 #endif
 138
 139     return mounted;
 140 }
 141
 142 static int get_free_volume(void)
 143 {
 144     int i;
 145     for (i=0; i<NUM_VOLUMES; i++)
 146     {
 147         if (vol_drive[i] == -1) /* unassigned? */
 148             return i;
 149     }
 150
 151     return -1; /* none found */
 152 }
 153
 154 int disk_mount(int drive)
 155 {
 156     int mounted = 0; /* reset partition-on-drive flag */
 157     int volume = get_free_volume();
 158     struct partinfo* pinfo = disk_init(IF_MV(drive));
 159
 160     if (pinfo == NULL)
 161     {
 162         return 0;
 163     }
 164 #if defined(TOSHIBA_GIGABEAT_S)
 165     int i = 1;  /* For the Gigabeat S, we mount the second partition */
 166 #else
 167     int i = 0;
 168 #endif
 169     for (; volume != -1 && i<4; i++)
 170     {
 171         if (memchr(fat_partition_types, pinfo[i].type,
 172                    sizeof(fat_partition_types)) == NULL)
 173             continue;  /* not an accepted partition type */
 174
 175 #ifdef MAX_LOG_SECTOR_SIZE
 176         int j;
 177
 178         for (j = 1; j <= (MAX_LOG_SECTOR_SIZE/SECTOR_SIZE); j <<= 1)
 179         {
 180             if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start * j))
 181             {
 182                 pinfo[i].start *= j;
 183                 pinfo[i].size *= j;
 184                 mounted++;
 185                 vol_drive[volume] = drive; /* remember the drive for this volume */
 186                 volume = get_free_volume(); /* prepare next entry */
 187                 if (drive == 0)
 188                     disk_sector_multiplier = j;
 189                 break;
 190             }
 191         }
 192 #else
 193         if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) pinfo[i].start))
 194         {
 195             mounted++;
 196             vol_drive[volume] = drive; /* remember the drive for this volume */
 197             volume = get_free_volume(); /* prepare next entry */
 198         }
 199 #endif
 200     }
 201
 202     if (mounted == 0 && volume != -1) /* none of the 4 entries worked? */
 203     {   /* try "superfloppy" mode */
 204         DEBUGF("No partition found, trying to mount sector 0.\n");
 205         if (!fat_mount(IF_MV2(volume,) IF_MV2(drive,) 0))
 206         {
 207             mounted = 1;
 208             vol_drive[volume] = drive; /* remember the drive for this volume */
 209         }
 210     }
 211     return mounted;
 212 }
 213
 214 #ifdef HAVE_HOTSWAP
 215 int disk_unmount(int drive)
 216 {
 217     int unmounted = 0;
 218     int i;
 219     for (i=0; i<NUM_VOLUMES; i++)
 220     {
 221         if (vol_drive[i] == drive)
 222         {   /* force releasing resources */
 223             vol_drive[i] = -1; /* mark unused */
 224             unmounted++;
 225             release_files(i);
 226             release_dirs(i);
 227             fat_unmount(i, false);
 228         }
 229     }
 230
 231     return unmounted;
 232 }
 233 #endif /* #ifdef HAVE_HOTSWAP */