URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/bootloaders
- from Rev 375 to Rev 389
- ↔ Reverse comparison
Rev 375 → Rev 389
/orpmon/include/build.h
1,?rev1len? → ?rev2line?,?rev2len?
#define BUILD_VERSION "Fri Sep 24 16:06:14 BST 2010" |
#define BUILD_VERSION "Fri Oct 15 13:03:37 CEST 2010" |
/orpmon/include/sdc.h
0,0 → 1,160
#ifndef _SDC_H |
#define _SDC_H |
#include "board.h" |
#include "typedefs.h" |
|
#include "spr-defs.h" |
#include "support.h" |
//#include <stdlib.h> |
|
|
#define REG32(add) *((volatile unsigned long *)(add)) |
#define DBGA(stuff...) // printf("SDC_HAL:" stuff) |
/* Memory card sector size */ |
#define SECTOR_SIZE 512 |
|
#define SECTOR_TO_BLOCK(a) (a << 9) |
|
//SD_CONTROLLER Register |
#define WORD_0 0x00 |
#define WORD_1 0x40 |
#define WORD_2 0x80 |
#define WORD_3 0xC0 |
|
|
#define SD_ARG 0x00 |
#define SD_COMMAND 0x04 |
#define SD_STATUS 0x08 |
#define SD_RESP1 0x0c |
|
#define SD_CTRL 0x1c |
#define SD_BLOCK 0x20 |
#define SD_POWER 0x24 |
#define SD_SOFTWARE_RST 0x28 |
#define SD_TIMEOUT 0x2c |
#define SD_NORMAL_INT_STATUS 0x30 |
#define SD_ERROR_INT_STATUS 0x34 |
#define SD_NORMAL_INT_STATUS_ENABLE 0x38 |
#define SD_ERROR_INT_STATUS_ENABLE 0x3c |
#define SD_NOMAL_INT_SIGNAL_ENABLE 0x40 |
#define SD_ERROR_INT_SIGNAL_ENABLE 0x44 |
#define SD_CAPABILITY 0x48 |
#define SD_CLOCK_D 0x4c |
#define BD_STATUS 0x50 |
#define BD_ISR 0x54 |
#define BD_RX 0x60 |
#define BD_TX 0x80 |
|
#define CLK_CARD 25000000 |
#define CLK_CPU 25000000 |
#define CMD_TIMEOUT_MS ((CLK_CPU/CLK_CARD) * 512) |
#define MAX_POL 1000 |
#define SD_REG(REG) REG32(SDC_CONTROLLER_BASE+REG) |
|
|
//Commands |
#define CMD0 0x000 // software reset |
#define CMD2 0x200 |
#define CMD3 0x300 |
#define CMD7 0x700 |
#define CMD8 0x800 |
#define CMD9 0x900 // ask card to send card speficic data (CSD) |
#define CMD16 0x1000 // sets the block length used by the memory card |
#define CMD17 0x1100 // read single block |
|
#define ACMD41 0x2900 |
#define ACMD6 0x600 |
#define CMD55 0x3700 |
|
//CMD ARG |
//CMD8 |
#define VHS 0x100 //2.7-3.6V |
#define CHECK_PATTERN 0xAA |
//ACMD41 |
#define BUSY 0x80000000 |
#define HCS 0x40000000 |
#define VOLTAGE_MASK 0xFFFFFF |
|
//CMD7 |
#define READY_FOR_DATA 0x100 |
#define CARD_STATUS_STB 0x600 |
|
//Command setting |
#define CICE 0x10 |
#define CRCE 0x08 |
#define RSP_48 0x2 |
#define RSP_146 0x1 |
|
//Status Mask |
//Normal interupt status |
#define CMD_COMPLETE 0x1 |
#define EI 0x8000 |
|
//Error interupt status |
#define CMD_TIMEOUT 0x1 |
#define CCRC 0x1 |
#define CIE 0x8 |
|
#define CID_MID_MASK 0x7F8000 |
#define CID_OID_MASK 0x7FFF |
#define CID_B1 0x7F800000 |
#define CID_B2 0x7F8000 |
#define CID_B3 0x7F80 |
#define CID_B4 0x7F |
|
#define RCA_RCA_MASK 0xFFFF0000 |
|
#define WRITE_OP 1 |
#define READ_OP 0 |
|
|
typedef struct { |
unsigned long int pad:18; |
unsigned int cmdi:6; |
unsigned int cmdt:2; |
unsigned int dps:1; |
unsigned int cice:1; |
unsigned int crce:1; |
unsigned int rsvd:1; |
unsigned int rts:2; |
}sd_controller_csr ; |
|
|
|
typedef struct { |
char mid:8; |
short oid:16; |
unsigned char pnm[5]; |
char prv:8; |
int psn:32; |
char rsv:4; |
short mdt:12; |
}sd_card_cid; |
|
typedef struct { |
}sd_card_csd; |
|
typedef struct { |
int rca; |
int Voltage_window; |
char HCS_s; |
char Active; |
char phys_spec_2_0; |
int cid_reg; |
sd_card_csd * csd_reg; |
|
}sd_card ; |
|
extern volatile sd_card dev; |
|
unsigned char sd_wait_rsp(void); |
int setup_bd_transfer(boolean direction, int block_addr, volatile unsigned char *buff); |
void reset_card(void); |
int finnish_bd_transfer(void); |
int sd_setup_transfer (sd_card sd_card_0); |
int setBLockLength(void); |
|
int memCardInit(void); |
|
#endif // _SDC_H |
|
/orpmon/include/dosfs.h
0,0 → 1,410
/* |
DOSFS Embedded FAT-Compatible Filesystem |
(C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com) |
*/ |
|
#ifndef _DOSFS_H |
#define _DOSFS_H |
//#include <stdio.h> |
//#include <sys/types.h> |
//#include <stdint.h> |
#include "board.h" |
#include "typedefs.h" |
|
#include "spr-defs.h" |
#include "support.h" |
//#include <stdlib.h> |
|
#include "int.h" |
#include "uart.h" |
#include "screen.h" |
//=================================================================== |
char *strcpy2(char *dest, char* src); |
int memcmp2(const void *s1, const void *s2, size_t n); |
int strcmp2(const char * s1, const char * s2); |
|
typedef struct |
{ |
long int quot; |
long int rem; |
} ldiv_t; |
|
typedef struct |
{ |
int quot; |
int rem; |
} div_t; |
|
|
#define SECTOR_TO_BLOCK(a) ( (a) << 9) |
unsigned long int DFS_ReadSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int count); |
unsigned long int DFS_WriteSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int count); |
|
|
ldiv_t ldiv (long int numer, long int denom); |
div_t div ( int numer, int denom); |
|
//=================================================================== |
// Configurable items |
#define MAX_PATH 64 // Maximum path length (increasing this will |
// GREATLY increase stack requirements!) |
#define DIR_SEPARATOR '/' // character separating directory components |
|
// End of configurable items |
//=================================================================== |
|
//=================================================================== |
// 32-bit error codes |
#define DFS_OK 0 // no error |
#define DFS_EOF 1 // end of file (not an error) |
#define DFS_WRITEPROT 2 // volume is write protected |
#define DFS_NOTFOUND 3 // path or file not found |
#define DFS_PATHLEN 4 // path too long |
#define DFS_ALLOCNEW 5 // must allocate new directory cluster |
#define DFS_ERRMISC 0xffffffff // generic error |
|
//=================================================================== |
// File access modes |
#define DFS_READ 1 // read-only |
#define DFS_WRITE 2 // write-only |
|
//=================================================================== |
// Miscellaneous constants |
#define SECTOR_SIZE 512 // sector size in bytes |
|
//=================================================================== |
// Internal subformat identifiers |
#define FAT12 0 |
#define FAT16 1 |
#define FAT32 2 |
|
//=================================================================== |
// DOS attribute bits |
#define ATTR_READ_ONLY 0x01 |
#define ATTR_HIDDEN 0x02 |
#define ATTR_SYSTEM 0x04 |
#define ATTR_VOLUME_ID 0x08 |
#define ATTR_DIRECTORY 0x10 |
#define ATTR_ARCHIVE 0x20 |
#define ATTR_LONG_NAME (ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID) |
|
|
/* |
Directory entry structure |
note: if name[0] == 0xe5, this is a free dir entry |
if name[0] == 0x00, this is a free entry and all subsequent entries are free |
if name[0] == 0x05, the first character of the name is 0xe5 [a kanji nicety] |
|
Date format: bit 0-4 = day of month (1-31) |
bit 5-8 = month, 1=Jan..12=Dec |
bit 9-15 = count of years since 1980 (0-127) |
Time format: bit 0-4 = 2-second count, (0-29) |
bit 5-10 = minutes (0-59) |
bit 11-15= hours (0-23) |
*/ |
typedef struct _tagDIRENT { |
unsigned char name[11]; // filename |
unsigned char attr; // attributes (see ATTR_* constant definitions) |
unsigned char reserved; // reserved, must be 0 |
unsigned char crttimetenth; // create time, 10ths of a second (0-199 are valid) |
unsigned char crttime_l; // creation time low byte |
unsigned char crttime_h; // creation time high byte |
unsigned char crtdate_l; // creation date low byte |
unsigned char crtdate_h; // creation date high byte |
unsigned char lstaccdate_l; // last access date low byte |
unsigned char lstaccdate_h; // last access date high byte |
unsigned char startclus_h_l; // high word of first cluster, low byte (FAT32) |
unsigned char startclus_h_h; // high word of first cluster, high byte (FAT32) |
unsigned char wrttime_l; // last write time low byte |
unsigned char wrttime_h; // last write time high byte |
unsigned char wrtdate_l; // last write date low byte |
unsigned char wrtdate_h; // last write date high byte |
unsigned char startclus_l_l; // low word of first cluster, low byte |
unsigned char startclus_l_h; // low word of first cluster, high byte |
unsigned char filesize_0; // file size, low byte |
unsigned char filesize_1; // |
unsigned char filesize_2; // |
unsigned char filesize_3; // file size, high byte |
} DIRENT, *PDIRENT; |
|
/* |
Partition table entry structure |
*/ |
typedef struct _tagPTINFO { |
unsigned char active; // 0x80 if partition active |
unsigned char start_h; // starting head |
unsigned char start_cs_l; // starting cylinder and sector (low byte) |
unsigned char start_cs_h; // starting cylinder and sector (high byte) |
unsigned char type; // type ID byte |
unsigned char end_h; // ending head |
unsigned char end_cs_l; // ending cylinder and sector (low byte) |
unsigned char end_cs_h; // ending cylinder and sector (high byte) |
unsigned char start_0; // starting sector# (low byte) |
unsigned char start_1; // |
unsigned char start_2; // |
unsigned char start_3; // starting sector# (high byte) |
unsigned char size_0; // size of partition (low byte) |
unsigned char size_1; // |
unsigned char size_2; // |
unsigned char size_3; // size of partition (high byte) |
} PTINFO, *PPTINFO; |
|
/* |
Master Boot Record structure |
*/ |
typedef struct _tagMBR { |
unsigned char bootcode[0x1be]; // boot sector |
PTINFO ptable[4] __attribute__((__packed__)); |
; // four partition table structures |
unsigned char sig_55; // 0x55 signature byte |
unsigned char sig_aa; // 0xaa signature byte |
} MBR, *PMBR; |
|
/* |
BIOS Parameter Block structure (FAT12/16) |
*/ |
typedef struct _tagBPB { |
unsigned char bytepersec_l; // bytes per sector low byte (0x00) |
unsigned char bytepersec_h; // bytes per sector high byte (0x02) |
unsigned char secperclus; // sectors per cluster (1,2,4,8,16,32,64,128 are valid) |
unsigned char reserved_l; // reserved sectors low byte |
unsigned char reserved_h; // reserved sectors high byte |
unsigned char numfats; // number of FAT copies (2) |
unsigned char rootentries_l; // number of root dir entries low byte (0x00 normally) |
unsigned char rootentries_h; // number of root dir entries high byte (0x02 normally) |
unsigned char sectors_s_l; // small num sectors low byte |
unsigned char sectors_s_h; // small num sectors high byte |
unsigned char mediatype; // media descriptor byte |
unsigned char secperfat_l; // sectors per FAT low byte |
unsigned char secperfat_h; // sectors per FAT high byte |
unsigned char secpertrk_l; // sectors per track low byte |
unsigned char secpertrk_h; // sectors per track high byte |
unsigned char heads_l; // heads low byte |
unsigned char heads_h; // heads high byte |
unsigned char hidden_0; // hidden sectors low byte |
unsigned char hidden_1; // (note - this is the number of MEDIA sectors before |
unsigned char hidden_2; // first sector of VOLUME - we rely on the MBR instead) |
unsigned char hidden_3; // hidden sectors high byte |
unsigned char sectors_l_0; // large num sectors low byte |
unsigned char sectors_l_1; // |
unsigned char sectors_l_2; // |
unsigned char sectors_l_3; // large num sectors high byte |
} BPB, *PBPB; |
|
|
|
|
/* |
Extended BIOS Parameter Block structure (FAT12/16) |
*/ |
typedef struct _tagEBPB { |
unsigned char unit; // int 13h drive# |
unsigned char head; // archaic, used by Windows NT-class OSes for flags |
unsigned char signature; // 0x28 or 0x29 |
unsigned char serial_0; // serial# |
unsigned char serial_1; // serial# |
unsigned char serial_2; // serial# |
unsigned char serial_3; // serial# |
unsigned char label[11]; // volume label |
unsigned char system[8]; // filesystem ID |
} EBPB, *PEBPB; |
|
/* |
Extended BIOS Parameter Block structure (FAT32) |
*/ |
typedef struct _tagEBPB32 { |
unsigned char fatsize_0; // big FAT size in sectors low byte |
unsigned char fatsize_1; // |
unsigned char fatsize_2; // |
unsigned char fatsize_3; // big FAT size in sectors high byte |
unsigned char extflags_l; // extended flags low byte |
unsigned char extflags_h; // extended flags high byte |
unsigned char fsver_l; // filesystem version (0x00) low byte |
unsigned char fsver_h; // filesystem version (0x00) high byte |
unsigned char root_0; // cluster of root dir, low byte |
unsigned char root_1; // |
unsigned char root_2; // |
unsigned char root_3; // cluster of root dir, high byte |
unsigned char fsinfo_l; // sector pointer to FSINFO within reserved area, low byte (2) |
unsigned char fsinfo_h; // sector pointer to FSINFO within reserved area, high byte (0) |
unsigned char bkboot_l; // sector pointer to backup boot sector within reserved area, low byte (6) |
unsigned char bkboot_h; // sector pointer to backup boot sector within reserved area, high byte (0) |
unsigned char reserved[12]; // reserved, should be 0 |
|
unsigned char unit; // int 13h drive# |
unsigned char head; // archaic, used by Windows NT-class OSes for flags |
unsigned char signature; // 0x28 or 0x29 |
unsigned char serial_0; // serial# |
unsigned char serial_1; // serial# |
unsigned char serial_2; // serial# |
unsigned char serial_3; // serial# |
unsigned char label[11]; // volume label |
unsigned char system[8]; // filesystem ID |
} EBPB32, *PEBPB32; |
|
/* |
Logical Boot Record structure (volume boot sector) |
*/ |
typedef struct _tagLBR { |
unsigned char jump[3]; // JMP instruction |
unsigned char oemid[8]; // OEM ID, space-padded |
BPB bpb __attribute__((__packed__)); // BIOS Parameter Block |
union { |
EBPB ebpb __attribute__((__packed__)); // FAT12/16 Extended BIOS Parameter Block |
EBPB32 ebpb32 __attribute__((__packed__)); // FAT32 Extended BIOS Parameter Block |
} ebpb; |
unsigned char code[420]; // boot sector code |
unsigned char sig_55; // 0x55 signature byte |
unsigned char sig_aa; // 0xaa signature byte |
} LBR, *PLBR; |
|
/* |
Volume information structure (Internal to DOSFS) |
*/ |
typedef struct _tagVOLINFO { |
unsigned char unit; // unit on which this volume resides |
unsigned char filesystem; // formatted filesystem |
|
// These two fields aren't very useful, so support for them has been commented out to |
// save memory. (Note that the "system" tag is not actually used by DOS to determine |
// filesystem type - that decision is made entirely on the basis of how many clusters |
// the drive contains. DOSFS works the same way). |
// See tag: OEMID in dosfs.c |
// unsigned char oemid[9]; // OEM ID ASCIIZ |
// unsigned char system[9]; // system ID ASCIIZ |
unsigned char label[12]; // volume label ASCIIZ |
unsigned long int startsector; // starting sector of filesystem |
unsigned char secperclus; // sectors per cluster |
unsigned short int reservedsecs; // reserved sectors |
unsigned long int numsecs; // number of sectors in volume |
unsigned long int secperfat; // sectors per FAT |
unsigned short int rootentries; // number of root dir entries |
|
unsigned long int numclusters; // number of clusters on drive |
|
// The fields below are PHYSICAL SECTOR NUMBERS. |
unsigned long int fat1; // starting sector# of FAT copy 1 |
unsigned long int rootdir; // starting sector# of root directory (FAT12/FAT16) or cluster (FAT32) |
unsigned long int dataarea; // starting sector# of data area (cluster #2) |
} VOLINFO, *PVOLINFO; |
|
/* |
Flags in DIRINFO.flags |
*/ |
#define DFS_DI_BLANKENT 0x01 // Searching for blank entry |
|
/* |
Directory search structure (Internal to DOSFS) |
*/ |
typedef struct _tagDIRINFO { |
unsigned long int currentcluster; // current cluster in dir |
unsigned char currentsector; // current sector in cluster |
unsigned char currententry; // current dir entry in sector |
unsigned char *scratch; // ptr to user-supplied scratch buffer (one sector) |
unsigned char flags; // internal DOSFS flags |
} DIRINFO, *PDIRINFO; |
|
/* |
File handle structure (Internal to DOSFS) |
*/ |
typedef struct _tagFILEINFO { |
PVOLINFO volinfo __attribute__((__packed__)); // VOLINFO used to open this file |
unsigned long int dirsector; // physical sector containing dir entry of this file |
unsigned char diroffset; // # of this entry within the dir sector |
unsigned char mode; // mode in which this file was opened |
unsigned long int firstcluster; // first cluster of file |
unsigned long int filelen; // byte length of file |
|
unsigned long int cluster; // current cluster |
unsigned long int pointer; // current (BYTE) pointer |
} FILEINFO, *PFILEINFO; |
|
/* |
Get starting sector# of specified partition on drive #unit |
NOTE: This code ASSUMES an MBR on the disk. |
scratchsector should point to a SECTOR_SIZE scratch area |
Returns 0xffffffff for any error. |
If pactive is non-NULL, this function also returns the partition active flag. |
If pptype is non-NULL, this function also returns the partition type. |
If psize is non-NULL, this function also returns the partition size. |
*/ |
unsigned long int init_fat(VOLINFO *vis); |
|
unsigned long int DFS_GetPtnStart(unsigned char unit, unsigned char *scratchsector, unsigned char pnum, unsigned char *pactive, unsigned char *pptype, unsigned long int *psize); |
|
/* |
Retrieve volume info from BPB and store it in a VOLINFO structure |
You must provide the unit and starting sector of the filesystem, and |
a pointer to a sector buffer for scratch |
Attempts to read BPB and glean information about the FS from that. |
Returns 0 OK, nonzero for any error. |
*/ |
unsigned long int DFS_GetVolInfo(unsigned char unit, unsigned char *scratchsector, unsigned long int startsector, PVOLINFO volinfo); |
|
/* |
Open a directory for enumeration by DFS_GetNextDirEnt |
You must supply a populated VOLINFO (see DFS_GetVolInfo) |
The empty string or a string containing only the directory separator are |
considered to be the root directory. |
Returns 0 OK, nonzero for any error. |
*/ |
unsigned long int DFS_OpenDir(PVOLINFO volinfo, unsigned char *dirname, PDIRINFO dirinfo); |
|
/* |
Get next entry in opened directory structure. Copies fields into the dirent |
structure, updates dirinfo. Note that it is the _caller's_ responsibility to |
handle the '.' and '..' entries. |
A deleted file will be returned as a NULL entry (first char of filename=0) |
by this code. Filenames beginning with 0x05 will be translated to 0xE5 |
automatically. Long file name entries will be returned as NULL. |
returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid, |
or DFS_ERRMISC for a media error |
*/ |
unsigned long int DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent); |
|
/* |
Open a file for reading or writing. You supply populated VOLINFO, a path to the file, |
mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to |
provide a pointer to a sector-sized scratch buffer. |
Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used |
to access the file from this point on. |
*/ |
unsigned long int DFS_OpenFile(PVOLINFO volinfo, unsigned char *path, unsigned char mode, unsigned char *scratch, PFILEINFO fileinfo); |
|
/* |
Read an open file |
You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a |
pointer to a SECTOR_SIZE scratch buffer. |
Note that returning DFS_EOF is not an error condition. This function updates the |
successcount field with the number of bytes actually read. |
*/ |
unsigned long int DFS_ReadFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len); |
|
/* |
Write an open file |
You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a |
pointer to a SECTOR_SIZE scratch buffer. |
This function updates the successcount field with the number of bytes actually written. |
*/ |
unsigned long int DFS_WriteFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len); |
|
/* |
Seek file pointer to a given position |
This function does not return status - refer to the fileinfo->pointer value |
to see where the pointer wound up. |
Requires a SECTOR_SIZE scratch buffer |
*/ |
void DFS_Seek(PFILEINFO fileinfo, unsigned long int offset, unsigned char *scratch); |
|
/* |
Delete a file |
scratch must point to a sector-sized buffer |
*/ |
unsigned long int DFS_UnlinkFile(PVOLINFO volinfo, unsigned char *path, unsigned char *scratch); |
|
// If we are building a host-emulation version, include host support |
#ifdef HOSTVER |
#include "hostemu.h" |
#endif |
|
#endif // _DOSFS_H |
orpmon/include/dosfs.h
Property changes :
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: orpmon/include/typedefs.h
===================================================================
--- orpmon/include/typedefs.h (nonexistent)
+++ orpmon/include/typedefs.h (revision 389)
@@ -0,0 +1,42 @@
+/*****************************************************************************
+ File name: typedefs.h
+
+ Description: This header file contains type definitions.
+
+ Copyright (C) 2004, HUE-Mobile Enterprises, All Rights Reserved
+
+ The information contained herein is confidential property of HUE-Mobile
+ Enterprises. The use, copying, transfer or disclosure of such
+ information is prohibited except by express written agreement with
+ HUE-Mobile Enterprises.
+******************************************************************************
+ Change Log
+ Date By Whom Change
+--------------+-------------------+-------------------------------------------
+ Jun-17-2004 Alex Jiang Created.
+
+******************************************************************************/
+#ifndef TYPEDEFS_H
+#define TYPEDEFS_H
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+typedef unsigned char boolean;
+
+#define to_boolean(b) (((b) != 0) ? TRUE : FALSE)
+
+typedef unsigned char uint8;
+typedef unsigned short int uint16;
+typedef unsigned long int uint32;
+
+typedef signed char int8;
+typedef signed short int int16;
+typedef signed long int int32;
+
+
+#endif //TYPEDEFS_H
Index: orpmon/include/board.h
===================================================================
--- orpmon/include/board.h (revision 375)
+++ orpmon/include/board.h (revision 389)
@@ -25,6 +25,8 @@
*/
#define IPCONFIG 3
+#define SDC_CONTROLLER_BASE 0x9e000000
+
#if BOARD==0
// Nibbler on bender1
@@ -50,6 +52,7 @@
# define IN_CLK 50000000
# define FLASH_ORG_16_2 1
# define BOARD_DEF_NAME "marvin"
+
#elif BOARD==2
//ORSoC usbethdev board
/orpmon/cmds/load.c
1,8 → 1,9
#include "common.h" |
#include "common.h" |
#include "support.h" |
#include "flash.h" |
#include "net.h" |
#include "uart.h" |
#include "dosfs.h" |
#include "spr-defs.h" |
|
#ifndef MAX_IMAGES |
656,14 → 657,111
return 0; |
} |
|
int sdboot_cmd (int argc, char *argv[]) |
{ |
VOLINFO vi; |
unsigned char *buf_ptr; |
|
unsigned char sector[SECTOR_SIZE], sector2[SECTOR_SIZE]; |
FILEINFO fi; |
unsigned long int pstart,psize, i,fisz; |
unsigned char pactive, ptype; |
DIRINFO di; |
DIRENT de; |
unsigned long int cache; |
|
// Obtain pointer to first partition on first (only) unit |
// Disable data cache if present |
if (mfspr(SPR_SR) & SPR_SR_DCE) |
{ |
printf("Disabling data cache\n"); |
dc_disable_cmd(0, 0); |
} |
|
|
buf_ptr=global.src_addr; |
|
|
printf("SD-BOOT start \n"); |
i=init_fat(&vi); |
|
|
|
printf("Volume label '%-11.11s'\n", vi.label); |
printf("%d sector/s per cluster, %d reserved sector/s, volume total %d sectors.\n", vi.secperclus, vi.reservedsecs, vi.numsecs); |
printf("%d sectors per FAT, first FAT at sector #%d, root dir at #%d.\n",vi.secperfat,vi.fat1,vi.rootdir); |
printf("(For FAT32, the root dir is a CLUSTER number, FAT12/16 it is a SECTOR number)\n"); |
printf("%d root dir entries, data area commences at sector #%d.\n",vi.rootentries,vi.dataarea); |
printf("%d clusters (%d bytes) in data area, filesystem IDd as ", vi.numclusters, vi.numclusters * vi.secperclus * SECTOR_SIZE); |
if (vi.filesystem == FAT12) |
printf("FAT12.\n"); |
else if (vi.filesystem == FAT16) |
printf("FAT16.\n"); |
else if (vi.filesystem == FAT32) |
printf("FAT32.\n"); |
else |
printf("[unknown]\n"); |
|
|
|
if (DFS_OpenDir(&vi, "", &di)) { |
printf("Error opening root directory\n"); |
return -1; |
} |
|
|
printf("Readback test\n"); |
if (DFS_OpenFile(&vi,"vmlinux.bin", DFS_READ, sector, &fi)) { |
printf("error opening file\n"); |
|
return -1; |
} |
|
printf("fi.filen %d, pointer adress:%d, data:%d \n", fi.filelen, buf_ptr, *buf_ptr); |
|
|
DFS_ReadFile(&fi, sector, buf_ptr, &i, fi.filelen); |
printf("\n read complete %d bytes (expected %d) pointer %d\n", i, fi.filelen, fi.pointer); |
|
|
|
if (global.src_addr > 0) |
{ |
/* the point of no return */ |
printf("tboot: copying 0x%lx -> 0x0, image size 0x%x...\n", |
global.src_addr, i); |
} |
|
|
|
|
// Disable timer: clear it all! |
mtspr (SPR_SR, mfspr(SPR_SR) & ~SPR_SR_TEE); |
mtspr(SPR_TTMR, 0); |
|
// Put the copyboot program at 24MB mark in memory |
#define COPYBOOT_LOCATION (1024*1024*24) |
printf("tboot: relocating copy loop to 0x%x ...\n", (unsigned long)COPYBOOT_LOCATION); |
// Setup where we'll copy the relocation function to |
void (*relocated_function)(unsigned long, unsigned long, unsigned long, int) |
= (void*) COPYBOOT_LOCATION; |
// Now copy the function there, 32 words worth, increase this if needed... |
relocate_code((void*)COPYBOOT_LOCATION, copy_and_boot, 32); |
// Indicate we'll jump there... |
printf("tboot: Relocate (%d bytes from 0x%x to 0) and boot image, ...\n", i, (unsigned long) global.src_addr); |
// Now do the copy and boot |
(*relocated_function)(global.src_addr, 0x0, 0x0 + i, 0); |
|
return 0; |
|
} |
|
void module_load_init (void) |
{ |
|
register_command ("tftp_conf", "[ <file> [ <srv_ip> [ <src_addr>]]]", "TFTP configuration", tftp_conf_cmd); |
register_command ("tboot", "[<image number>]", "Bootstrap image downloaded via tftp", tboot_cmd); |
register_command ("sdboot", "[<image number>]", "Read image from SD-CARD", sdboot_cmd); |
#if 0 |
register_command ("tftp", "[<file> [<srv_ip> [<src_addr>]]]", "TFTP download", tftp_cmd); |
register_command ("copy", "[<dst_addr> [<src_addr [<length>]]]", "Copy memory", copy_cmd); |
674,4 → 772,5
register_command ("boot_flash", "[<start_addr>]", "Boot image from <start_addr> (default from flash)", boot_flash_cmd); |
#endif |
init_load(); |
|
} |
/orpmon/common/dosfs.c
0,0 → 1,1492
/* |
DOSFS Embedded FAT-Compatible Filesystem |
(C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com) |
|
You are permitted to modify and/or use this code in your own projects without |
payment of royalty, regardless of the license(s) you choose for those projects. |
|
You cannot re-copyright or restrict use of the code as released by Lewin Edwards. |
*/ |
|
/* |
@2010, adam.edvardsson@orsoc.se |
Added local copy of the functions, |
div_t, memcmp2,strcpy2,strcmp2. The one from the string library is not comatible |
|
*/ |
|
|
//#include <string.h> |
//#include <stdlib.h> |
//#include "or32_utils.h" |
#include "dosfs.h" |
#include "sdc.h" |
|
#include "common.h" |
#include "support.h" |
#include "uart.h" |
|
|
|
unsigned long int init_fat(VOLINFO *vis){ |
|
|
|
unsigned char sector[SECTOR_SIZE]; |
unsigned long int pstart,psize, i,fisz; |
unsigned char pactive, ptype; |
VOLINFO vi; |
|
|
//uart_init(DEFAULT_UART); |
printf("FAT INIT START\n"); |
memCardInit(); |
|
|
pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize); |
if (pstart == 0xffffffff) { |
printf("Cannot find first partition\n"); |
return -1; |
} |
|
printf("Partition 0 start sector 0x%-08.8lX active %-02.2hX type %-02.2hX size %-08.8lX\n", pstart, pactive, ptype, psize); |
|
if (DFS_GetVolInfo(0, sector, pstart, &vi)) { |
printf("Error getting volume information\n"); |
return -1; |
} |
|
|
|
|
*vis=vi; |
|
|
|
} |
|
|
unsigned long int DFS_ReadSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int count) |
{ |
|
unsigned long int block_add = 0; |
int i ; |
|
|
|
for (i=0; i<count; i++){ |
block_add=sector+i; |
DBGA("\n readSector %u, block_addr %u \n",sector,block_add); |
setup_bd_transfer(READ_OP, block_add , buffer); |
if (finnish_bd_transfer() == FALSE) |
return 0xff; |
|
} |
|
return 0; |
|
} |
|
|
unsigned long int DFS_WriteSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int count) |
{ |
|
|
unsigned long int block_add = 0; |
unsigned char scr[SECTOR_SIZE]; |
|
block_add=sector; |
DBGA("\n writeSector %u, block_addr2 %u \n",sector,block_add); |
setup_bd_transfer(WRITE_OP, block_add , buffer); |
|
if (finnish_bd_transfer() == FALSE){ |
printf("TRANSACTION FAILED, Buffer %x \n", buffer); |
|
//reset_card(); |
// sd_wait_rsp(); |
// SD_REG(SD_SOFTWARE_RST)=1; |
|
//SD_REG(SD_SOFTWARE_RST)=0; |
|
|
DBGA("FREE BD TX/RX: 0x%x \n", SD_REG(BD_STATUS) ); |
|
|
DBGA("TRY READ SECTOR \n"); |
setup_bd_transfer(READ_OP, 526571008 , scr); |
finnish_bd_transfer(); |
DBGA("PRINT test wreite to 526571008 \n"); |
setup_bd_transfer(WRITE_OP, 526571008 , scr); |
finnish_bd_transfer(); |
|
setup_bd_transfer(WRITE_OP, block_add , buffer); |
if (finnish_bd_transfer() == FALSE){ |
printf("TRANSACTION FAILED AGAIN!, Buffer %x \n", buffer); |
return 0xff; |
} |
|
} |
|
|
return 0; |
|
} |
|
/* |
Get starting sector# of specified partition on drive #unit |
NOTE: This code ASSUMES an MBR on the disk. |
scratchsector should point to a SECTOR_SIZE scratch area |
Returns 0xffffffff for any error. |
If pactive is non-NULL, this function also returns the partition active flag. |
If pptype is non-NULL, this function also returns the partition type. |
If psize is non-NULL, this function also returns the partition size. |
*/ |
|
|
unsigned long int DFS_GetPtnStart(unsigned char unit, unsigned char *scratchsector, unsigned char pnum, unsigned char *pactive, unsigned char *pptype, unsigned long int *psize) |
{ |
unsigned long int result; |
PMBR mbr = (PMBR) scratchsector; |
|
// DOS ptable supports maximum 4 partitions |
if (pnum > 3) |
return DFS_ERRMISC; |
|
// Read MBR from target media |
if (DFS_ReadSector(unit,scratchsector,0,1)) { |
return DFS_ERRMISC; |
} |
|
result = (unsigned long int) mbr->ptable[pnum].start_0 | |
(((unsigned long int) mbr->ptable[pnum].start_1) << 8) | |
(((unsigned long int) mbr->ptable[pnum].start_2) << 16) | |
(((unsigned long int) mbr->ptable[pnum].start_3) << 24); |
|
|
//unsigned char active; // 0x80 if partition active |
//unsigned char start_h; // starting head |
//unsigned char start_cs_l; // starting cylinder and sector (low byte) |
//unsigned char start_cs_h; // starting cylinder and sector (high byte) |
|
printf("active 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].active, mbr->ptable[pnum].start_h, mbr->ptable[pnum].start_cs_l,mbr->ptable[pnum].start_cs_h); |
|
printf("start 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].start_0, mbr->ptable[pnum].start_1,mbr->ptable[pnum].start_2,mbr->ptable[pnum].start_3); |
if (pactive) |
*pactive = mbr->ptable[pnum].active; |
|
if (pptype) |
*pptype = mbr->ptable[pnum].type; |
|
if (psize){ |
*psize = (unsigned long int) mbr->ptable[pnum].size_0 | |
(((unsigned long int) mbr->ptable[pnum].size_1) << 8) | |
(((unsigned long int) mbr->ptable[pnum].size_2) << 16) | |
(((unsigned long int) mbr->ptable[pnum].size_3) << 24); |
printf("size 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].size_0, mbr->ptable[pnum].size_1,mbr->ptable[pnum].size_2,mbr->ptable[pnum].size_3); |
} |
|
return result; |
} |
|
|
|
ldiv_t ldiv (long int numer, long int denom) |
{ |
ldiv_t result; |
|
result.quot = numer / denom; |
result.rem = numer % denom; |
|
/* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where |
NUMER / DENOM is to be computed in infinite precision. In |
other words, we should always truncate the quotient towards |
zero, never -infinity. Machine division and remainer may |
work either way when one or both of NUMER or DENOM is |
negative. If only one is negative and QUOT has been |
truncated towards -infinity, REM will have the same sign as |
DENOM and the opposite sign of NUMER; if both are negative |
and QUOT has been truncated towards -infinity, REM will be |
positive (will have the opposite sign of NUMER). These are |
considered `wrong'. If both are NUM and DENOM are positive, |
RESULT will always be positive. This all boils down to: if |
NUMER >= 0, but REM < 0, we got the wrong answer. In that |
case, to get the right answer, add 1 to QUOT and subtract |
DENOM from REM. */ |
|
if (numer >= 0 && result.rem < 0) |
{ |
++result.quot; |
result.rem -= denom; |
} |
|
return result; |
} |
|
div_t div ( int numer, int denom) |
{ |
div_t result; |
|
result.quot = numer / denom; |
result.rem = numer % denom; |
|
/* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where |
NUMER / DENOM is to be computed in infinite precision. In |
other words, we should always truncate the quotient towards |
zero, never -infinity. Machine division and remainer may |
work either way when one or both of NUMER or DENOM is |
negative. If only one is negative and QUOT has been |
truncated towards -infinity, REM will have the same sign as |
DENOM and the opposite sign of NUMER; if both are negative |
and QUOT has been truncated towards -infinity, REM will be |
positive (will have the opposite sign of NUMER). These are |
considered `wrong'. If both are NUM and DENOM are positive, |
RESULT will always be positive. This all boils down to: if |
NUMER >= 0, but REM < 0, we got the wrong answer. In that |
case, to get the right answer, add 1 to QUOT and subtract |
DENOM from REM. */ |
|
if (numer >= 0 && result.rem < 0) |
{ |
++result.quot; |
result.rem -= denom; |
} |
|
return result; |
} |
/* |
Retrieve volume info from BPB and store it in a VOLINFO structure |
You must provide the unit and starting sector of the filesystem, and |
a pointer to a sector buffer for scratch |
Attempts to read BPB and glean information about the FS from that. |
Returns 0 OK, nonzero for any error. |
*/ |
unsigned long int DFS_GetVolInfo(unsigned char unit, unsigned char *scratchsector, unsigned long int startsector, PVOLINFO volinfo) |
{ |
PLBR lbr = (PLBR) scratchsector; |
volinfo->unit = unit; |
volinfo->startsector = startsector; |
|
if(DFS_ReadSector(unit,scratchsector,startsector,1)) |
return DFS_ERRMISC; |
|
// tag: OEMID, refer dosfs.h |
// strncpy(volinfo->oemid, lbr->oemid, 8); |
// volinfo->oemid[8] = 0; |
|
volinfo->secperclus = lbr->bpb.secperclus; |
volinfo->reservedsecs = (unsigned short) lbr->bpb.reserved_l | |
(((unsigned short) lbr->bpb.reserved_h) << 8); |
|
volinfo->numsecs = (unsigned short) lbr->bpb.sectors_s_l | |
(((unsigned short) lbr->bpb.sectors_s_h) << 8); |
|
if (!volinfo->numsecs) |
volinfo->numsecs = (unsigned long int) lbr->bpb.sectors_l_0 | |
(((unsigned long int) lbr->bpb.sectors_l_1) << 8) | |
(((unsigned long int) lbr->bpb.sectors_l_2) << 16) | |
(((unsigned long int) lbr->bpb.sectors_l_3) << 24); |
|
// If secperfat is 0, we must be in a FAT32 volume; get secperfat |
// from the FAT32 EBPB. The volume label and system ID string are also |
// in different locations for FAT12/16 vs FAT32. |
volinfo->secperfat = (unsigned short) lbr->bpb.secperfat_l | |
(((unsigned short) lbr->bpb.secperfat_h) << 8); |
if (!volinfo->secperfat) { |
volinfo->secperfat = (unsigned long int) lbr->ebpb.ebpb32.fatsize_0 | |
(((unsigned long int) lbr->ebpb.ebpb32.fatsize_1) << 8) | |
(((unsigned long int) lbr->ebpb.ebpb32.fatsize_2) << 16) | |
(((unsigned long int) lbr->ebpb.ebpb32.fatsize_3) << 24); |
|
memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11); |
volinfo->label[11] = 0; |
|
// tag: OEMID, refer dosfs.h |
// memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8); |
// volinfo->system[8] = 0; |
} |
else { |
memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11); |
volinfo->label[11] = 0; |
|
// tag: OEMID, refer dosfs.h |
// memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8); |
// volinfo->system[8] = 0; |
} |
|
// note: if rootentries is 0, we must be in a FAT32 volume. |
volinfo->rootentries = (unsigned short) lbr->bpb.rootentries_l | |
(((unsigned short) lbr->bpb.rootentries_h) << 8); |
|
// after extracting raw info we perform some useful precalculations |
volinfo->fat1 = startsector + volinfo->reservedsecs; |
|
// The calculation below is designed to round up the root directory size for FAT12/16 |
// and to simply ignore the root directory for FAT32, since it's a normal, expandable |
// file in that situation. |
if (volinfo->rootentries) { |
volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2); |
volinfo->dataarea = volinfo->rootdir + (((volinfo->rootentries * 32) + (SECTOR_SIZE - 1)) / SECTOR_SIZE); |
} |
else { |
volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2); |
volinfo->rootdir = (unsigned long int) lbr->ebpb.ebpb32.root_0 | |
(((unsigned long int) lbr->ebpb.ebpb32.root_1) << 8) | |
(((unsigned long int) lbr->ebpb.ebpb32.root_2) << 16) | |
(((unsigned long int) lbr->ebpb.ebpb32.root_3) << 24); |
} |
|
// Calculate number of clusters in data area and infer FAT type from this information. |
volinfo->numclusters = (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus; |
if (volinfo->numclusters < 4085) |
volinfo->filesystem = FAT12; |
else if (volinfo->numclusters < 65525) |
volinfo->filesystem = FAT16; |
else |
volinfo->filesystem = FAT32; |
|
return DFS_OK; |
} |
|
/* |
Fetch FAT entry for specified cluster number |
You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO |
Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired |
FAT entry. |
scratchcache should point to a UINT32. This variable caches the physical sector number |
last read into the scratch buffer for performance enhancement reasons. |
*/ |
unsigned long int DFS_GetFAT(PVOLINFO volinfo, unsigned char *scratch, unsigned long int *scratchcache, unsigned long int cluster) |
{ |
unsigned long int offset, sector, result; |
|
if (volinfo->filesystem == FAT12) { |
offset = cluster + (cluster / 2); |
} |
else if (volinfo->filesystem == FAT16) { |
offset = cluster * 2; |
} |
else if (volinfo->filesystem == FAT32) { |
offset = cluster * 4; |
} |
else |
return 0x0ffffff7; // FAT32 bad cluster |
|
// at this point, offset is the BYTE offset of the desired sector from the start |
// of the FAT. Calculate the physical sector containing this FAT entry. |
sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; |
|
// If this is not the same sector we last read, then read it into RAM |
if (sector != *scratchcache) { |
if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { |
// avoid anyone assuming that this cache value is still valid, which |
// might cause disk corruption |
*scratchcache = 0; |
return 0x0ffffff7; // FAT32 bad cluster |
} |
*scratchcache = sector; |
} |
|
// At this point, we "merely" need to extract the relevant entry. |
// This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry |
// may span a sector boundary. The normal way around this is always to read two |
// FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. |
offset = ldiv(offset, SECTOR_SIZE).rem; |
|
if (volinfo->filesystem == FAT12) { |
// Special case for sector boundary - Store last byte of current sector. |
// Then read in the next sector and put the first byte of that sector into |
// the high byte of result. |
if (offset == SECTOR_SIZE - 1) { |
result = (unsigned long int) scratch[offset]; |
sector++; |
if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { |
// avoid anyone assuming that this cache value is still valid, which |
// might cause disk corruption |
*scratchcache = 0; |
return 0x0ffffff7; // FAT32 bad cluster |
} |
*scratchcache = sector; |
// Thanks to Claudio Leonel for pointing out this missing line. |
result |= ((unsigned long int) scratch[0]) << 8; |
} |
else { |
result = (unsigned long int) scratch[offset] | |
((unsigned long int) scratch[offset+1]) << 8; |
} |
if (cluster & 1) |
result = result >> 4; |
else |
result = result & 0xfff; |
} |
else if (volinfo->filesystem == FAT16) { |
result = (unsigned long int) scratch[offset] | |
((unsigned long int) scratch[offset+1]) << 8; |
} |
else if (volinfo->filesystem == FAT32) { |
result = ((unsigned long int) scratch[offset] | |
((unsigned long int) scratch[offset+1]) << 8 | |
((unsigned long int) scratch[offset+2]) << 16 | |
((unsigned long int) scratch[offset+3]) << 24) & 0x0fffffff; |
} |
else |
result = 0x0ffffff7; // FAT32 bad cluster |
return result; |
} |
|
|
/* |
Set FAT entry for specified cluster number |
You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO |
Returns DFS_ERRMISC for any error, otherwise DFS_OK |
scratchcache should point to a UINT32. This variable caches the physical sector number |
last read into the scratch buffer for performance enhancement reasons. |
|
NOTE: This code is HIGHLY WRITE-INEFFICIENT, particularly for flash media. Considerable |
performance gains can be realized by caching the sector. However this is difficult to |
achieve on FAT12 without requiring 2 sector buffers of scratch space, and it is a design |
requirement of this code to operate on a single 512-byte scratch. |
|
If you are operating DOSFS over flash, you are strongly advised to implement a writeback |
cache in your physical I/O driver. This will speed up your code significantly and will |
also conserve power and flash write life. |
*/ |
unsigned long int DFS_SetFAT(PVOLINFO volinfo, unsigned char *scratch, unsigned long int *scratchcache, unsigned long int cluster, unsigned long int new_contents) |
{ |
unsigned long int offset, sector, result; |
if (volinfo->filesystem == FAT12) { |
offset = cluster + (cluster / 2); |
new_contents &=0xfff; |
} |
else if (volinfo->filesystem == FAT16) { |
offset = cluster * 2; |
new_contents &=0xffff; |
} |
else if (volinfo->filesystem == FAT32) { |
offset = cluster * 4; |
new_contents &=0x0fffffff; // FAT32 is really "FAT28" |
} |
else |
return DFS_ERRMISC; |
|
// at this point, offset is the BYTE offset of the desired sector from the start |
// of the FAT. Calculate the physical sector containing this FAT entry. |
sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; |
|
// If this is not the same sector we last read, then read it into RAM |
if (sector != *scratchcache) { |
if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { |
// avoid anyone assuming that this cache value is still valid, which |
// might cause disk corruption |
*scratchcache = 0; |
return DFS_ERRMISC; |
} |
*scratchcache = sector; |
} |
|
// At this point, we "merely" need to extract the relevant entry. |
// This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry |
// may span a sector boundary. The normal way around this is always to read two |
// FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. |
offset = ldiv(offset, SECTOR_SIZE).rem; |
|
if (volinfo->filesystem == FAT12) { |
|
// If this is an odd cluster, pre-shift the desired new contents 4 bits to |
// make the calculations below simpler |
if (cluster & 1) |
new_contents = new_contents << 4; |
|
// Special case for sector boundary |
if (offset == SECTOR_SIZE - 1) { |
|
// Odd cluster: High 12 bits being set |
if (cluster & 1) { |
scratch[offset] = (scratch[offset] & 0x0f) | new_contents & 0xf0; |
} |
// Even cluster: Low 12 bits being set |
else { |
scratch[offset] = new_contents & 0xff; |
} |
result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); |
// mirror the FAT into copy 2 |
if (DFS_OK == result) |
result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); |
|
// If we wrote that sector OK, then read in the subsequent sector |
// and poke the first byte with the remainder of this FAT entry. |
if (DFS_OK == result) { |
*scratchcache++; |
result = DFS_ReadSector(volinfo->unit, scratch, *scratchcache, 1); |
if (DFS_OK == result) { |
// Odd cluster: High 12 bits being set |
if (cluster & 1) { |
scratch[0] = new_contents & 0xff00; |
} |
// Even cluster: Low 12 bits being set |
else { |
scratch[0] = (scratch[0] & 0xf0) | new_contents & 0x0f; |
} |
result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); |
// mirror the FAT into copy 2 |
if (DFS_OK == result) |
result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); |
} |
else { |
// avoid anyone assuming that this cache value is still valid, which |
// might cause disk corruption |
*scratchcache = 0; |
} |
} |
} // if (offset == SECTOR_SIZE - 1) |
|
// Not a sector boundary. But we still have to worry about if it's an odd |
// or even cluster number. |
else { |
// Odd cluster: High 12 bits being set |
if (cluster & 1) { |
scratch[offset] = (scratch[offset] & 0x0f) | new_contents & 0xf0; |
scratch[offset+1] = new_contents & 0xff00; |
} |
// Even cluster: Low 12 bits being set |
else { |
scratch[offset] = new_contents & 0xff; |
scratch[offset+1] = (scratch[offset+1] & 0xf0) | new_contents & 0x0f; |
} |
result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); |
// mirror the FAT into copy 2 |
if (DFS_OK == result) |
result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); |
} |
} |
else if (volinfo->filesystem == FAT16) { |
scratch[offset] = (new_contents & 0xff); |
scratch[offset+1] = (new_contents & 0xff00) >> 8; |
result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); |
// mirror the FAT into copy 2 |
if (DFS_OK == result) |
result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); |
} |
else if (volinfo->filesystem == FAT32) { |
scratch[offset] = (new_contents & 0xff); |
scratch[offset+1] = (new_contents & 0xff00) >> 8; |
scratch[offset+2] = (new_contents & 0xff0000) >> 16; |
scratch[offset+3] = (scratch[offset+3] & 0xf0) | ((new_contents & 0x0f000000) >> 24); |
// Note well from the above: Per Microsoft's guidelines we preserve the upper |
// 4 bits of the FAT32 cluster value. It's unclear what these bits will be used |
// for; in every example I've encountered they are always zero. |
result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); |
// mirror the FAT into copy 2 |
if (DFS_OK == result) |
result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); |
} |
else |
result = DFS_ERRMISC; |
|
return result; |
} |
|
/* |
Convert a filename element from canonical (8.3) to directory entry (11) form |
src must point to the first non-separator character. |
dest must point to a 12-byte buffer. |
*/ |
unsigned char *DFS_CanonicalToDir(unsigned char *dest, unsigned char *src) |
{ |
unsigned char *destptr = dest; |
|
memset(dest, ' ', 11); |
dest[11] = 0; |
|
while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) { |
if (*src >= 'a' && *src <='z') { |
*destptr++ = (*src - 'a') + 'A'; |
src++; |
} |
else if (*src == '.') { |
src++; |
destptr = dest + 8; |
} |
else { |
*destptr++ = *src++; |
} |
} |
|
return dest; |
} |
|
/* |
Find the first unused FAT entry |
You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO |
Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired |
FAT entry. |
Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available |
*/ |
unsigned long int DFS_GetFreeFAT(PVOLINFO volinfo, unsigned char *scratch) |
{ |
unsigned long int i, result = 0xffffffff, scratchcache = 0; |
|
// Search starts at cluster 2, which is the first usable cluster |
// NOTE: This search can't terminate at a bad cluster, because there might |
// legitimately be bad clusters on the disk. |
for (i=2; i < volinfo->numclusters; i++) { |
result = DFS_GetFAT(volinfo, scratch, &scratchcache, i); |
if (!result) { |
return i; |
} |
} |
return 0x0ffffff7; // Can't find a free cluster |
} |
|
|
/* |
Open a directory for enumeration by DFS_GetNextDirEnt |
You must supply a populated VOLINFO (see DFS_GetVolInfo) |
The empty string or a string containing only the directory separator are |
considered to be the root directory. |
Returns 0 OK, nonzero for any error. |
*/ |
unsigned long int DFS_OpenDir(PVOLINFO volinfo, unsigned char *dirname, PDIRINFO dirinfo) |
{ |
// Default behavior is a regular search for existing entries |
dirinfo->flags = 0; |
|
if (!strlen((char *) dirname) || (strlen((char *) dirname) == 1 && dirname[0] == DIR_SEPARATOR)) { |
if (volinfo->filesystem == FAT32) { |
dirinfo->currentcluster = volinfo->rootdir; |
dirinfo->currentsector = 0; |
dirinfo->currententry = 0; |
|
// read first sector of directory |
return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1); |
} |
else { |
dirinfo->currentcluster = 0; |
dirinfo->currentsector = 0; |
dirinfo->currententry = 0; |
|
// read first sector of directory |
return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1); |
} |
} |
|
// This is not the root directory. We need to find the start of this subdirectory. |
// We do this by devious means, using our own companion function DFS_GetNext. |
else { |
unsigned char tmpfn[12]; |
unsigned char *ptr = dirname; |
unsigned long int result; |
DIRENT de; |
|
if (volinfo->filesystem == FAT32) { |
dirinfo->currentcluster = volinfo->rootdir; |
dirinfo->currentsector = 0; |
dirinfo->currententry = 0; |
|
// read first sector of directory |
if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1)) |
return DFS_ERRMISC; |
} |
else { |
dirinfo->currentcluster = 0; |
dirinfo->currentsector = 0; |
dirinfo->currententry = 0; |
|
// read first sector of directory |
if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1)) |
return DFS_ERRMISC; |
} |
|
// skip leading path separators |
while (*ptr == DIR_SEPARATOR && *ptr) |
ptr++; |
|
// Scan the path from left to right, finding the start cluster of each entry |
// Observe that this code is inelegant, but obviates the need for recursion. |
while (*ptr) { |
DFS_CanonicalToDir(tmpfn, ptr); |
|
de.name[0] = 0; |
|
do { |
result = DFS_GetNext(volinfo, dirinfo, &de); |
} while (!result && memcmp2(de.name, tmpfn, 11)); |
|
if (!memcmp2(de.name, tmpfn, 11) && ((de.attr & ATTR_DIRECTORY) == ATTR_DIRECTORY)) { |
if (volinfo->filesystem == FAT32) { |
dirinfo->currentcluster = (unsigned long int) de.startclus_l_l | |
((unsigned long int) de.startclus_l_h) << 8 | |
((unsigned long int) de.startclus_h_l) << 16 | |
((unsigned long int) de.startclus_h_h) << 24; |
} |
else { |
dirinfo->currentcluster = (unsigned long int) de.startclus_l_l | |
((unsigned long int) de.startclus_l_h) << 8; |
} |
dirinfo->currentsector = 0; |
dirinfo->currententry = 0; |
|
if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus), 1)) |
return DFS_ERRMISC; |
} |
else if (!memcmp2(de.name, tmpfn, 11) && !(de.attr & ATTR_DIRECTORY)) |
return DFS_NOTFOUND; |
|
// seek to next item in list |
while (*ptr != DIR_SEPARATOR && *ptr) |
ptr++; |
if (*ptr == DIR_SEPARATOR) |
ptr++; |
} |
|
if (!dirinfo->currentcluster) |
return DFS_NOTFOUND; |
} |
return DFS_OK; |
} |
|
/* |
Get next entry in opened directory structure. Copies fields into the dirent |
structure, updates dirinfo. Note that it is the _caller's_ responsibility to |
handle the '.' and '..' entries. |
A deleted file will be returned as a NULL entry (first char of filename=0) |
by this code. Filenames beginning with 0x05 will be translated to 0xE5 |
automatically. Long file name entries will be returned as NULL. |
returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid, |
or DFS_ERRMISC for a media error |
*/ |
unsigned long int DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent) |
{ |
unsigned long int tempint; // required by DFS_GetFAT |
|
// Do we need to read the next sector of the directory? |
if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) { |
dirinfo->currententry = 0; |
dirinfo->currentsector++; |
|
// Root directory; special case handling |
// Note that currentcluster will only ever be zero if both: |
// (a) this is the root directory, and |
// (b) we are on a FAT12/16 volume, where the root dir can't be expanded |
if (dirinfo->currentcluster == 0) { |
// Trying to read past end of root directory? |
if (dirinfo->currentsector * (SECTOR_SIZE / sizeof(DIRENT)) >= volinfo->rootentries) |
return DFS_EOF; |
|
// Otherwise try to read the next sector |
if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir + dirinfo->currentsector, 1)) |
return DFS_ERRMISC; |
} |
|
// Normal handling |
else { |
if (dirinfo->currentsector >= volinfo->secperclus) { |
dirinfo->currentsector = 0; |
if ((dirinfo->currentcluster >= 0xff7 && volinfo->filesystem == FAT12) || |
(dirinfo->currentcluster >= 0xfff7 && volinfo->filesystem == FAT16) || |
(dirinfo->currentcluster >= 0x0ffffff7 && volinfo->filesystem == FAT32)) { |
|
// We are at the end of the directory chain. If this is a normal |
// find operation, we should indicate that there is nothing more |
// to see. |
if (!(dirinfo->flags & DFS_DI_BLANKENT)) |
return DFS_EOF; |
|
// On the other hand, if this is a "find free entry" search, |
// we need to tell the caller to allocate a new cluster |
else |
return DFS_ALLOCNEW; |
} |
dirinfo->currentcluster = DFS_GetFAT(volinfo, dirinfo->scratch, &tempint, dirinfo->currentcluster); |
} |
if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus) + dirinfo->currentsector, 1)) |
return DFS_ERRMISC; |
} |
} |
|
memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]), sizeof(DIRENT)); |
|
if (dirent->name[0] == 0) { // no more files in this directory |
// If this is a "find blank" then we can reuse this name. |
if (dirinfo->flags & DFS_DI_BLANKENT) |
return DFS_OK; |
else |
return DFS_EOF; |
} |
|
if (dirent->name[0] == 0xe5) // handle deleted file entries |
dirent->name[0] = 0; |
else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME) |
dirent->name[0] = 0; |
else if (dirent->name[0] == 0x05) // handle kanji filenames beginning with 0xE5 |
dirent->name[0] = 0xe5; |
|
dirinfo->currententry++; |
|
return DFS_OK; |
} |
|
/* |
INTERNAL |
Find a free directory entry in the directory specified by path |
This function MAY cause a disk write if it is necessary to extend the directory |
size. |
Note - di.scratch must be preinitialized to point to a sector scratch buffer |
de is a scratch structure |
Returns DFS_ERRMISC if a new entry could not be located or created |
de is updated with the same return information you would expect from DFS_GetNext |
*/ |
unsigned long int DFS_GetFreeDirEnt(PVOLINFO volinfo, unsigned char *path, PDIRINFO di, PDIRENT de) |
{ |
unsigned long int tempclus,i; |
|
if (DFS_OpenDir(volinfo, path, di)) |
return DFS_NOTFOUND; |
|
// Set "search for empty" flag so DFS_GetNext knows what we're doing |
di->flags |= DFS_DI_BLANKENT; |
|
// We seek through the directory looking for an empty entry |
// Note we are reusing tempclus as a temporary result holder. |
tempclus = 0; |
do { |
tempclus = DFS_GetNext(volinfo, di, de); |
|
// Empty entry found |
if (tempclus == DFS_OK && (!de->name[0])) { |
return DFS_OK; |
} |
|
// End of root directory reached |
else if (tempclus == DFS_EOF) |
return DFS_ERRMISC; |
|
else if (tempclus == DFS_ALLOCNEW) { |
tempclus = DFS_GetFreeFAT(volinfo, di->scratch); |
if (tempclus == 0x0ffffff7) |
return DFS_ERRMISC; |
|
// write out zeroed sectors to the new cluster |
memset(di->scratch, 0, SECTOR_SIZE); |
for (i=0;i<volinfo->secperclus;i++) { |
if (DFS_WriteSector(volinfo->unit, di->scratch, volinfo->dataarea + ((tempclus - 2) * volinfo->secperclus) + i, 1)) |
return DFS_ERRMISC; |
} |
// Point old end cluster to newly allocated cluster |
i = 0; |
DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); |
|
// Update DIRINFO so caller knows where to place the new file |
di->currentcluster = tempclus; |
di->currentsector = 0; |
di->currententry = 1; // since the code coming after this expects to subtract 1 |
|
// Mark newly allocated cluster as end of chain |
switch(volinfo->filesystem) { |
case FAT12: tempclus = 0xff8; break; |
case FAT16: tempclus = 0xfff8; break; |
case FAT32: tempclus = 0x0ffffff8; break; |
default: return DFS_ERRMISC; |
} |
DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); |
} |
} while (!tempclus); |
|
// We shouldn't get here |
return DFS_ERRMISC; |
} |
|
/* |
Open a file for reading or writing. You supply populated VOLINFO, a path to the file, |
mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to |
provide a pointer to a sector-sized scratch buffer. |
Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used |
to access the file from this point on. |
*/ |
unsigned long int DFS_OpenFile(PVOLINFO volinfo, unsigned char *path, unsigned char mode, unsigned char *scratch, PFILEINFO fileinfo) |
{ |
unsigned char tmppath[MAX_PATH]; |
unsigned char filename[12]; |
unsigned char *p; |
DIRINFO di; |
DIRENT de; |
|
// larwe 2006-09-16 +1 zero out file structure |
memset(fileinfo, 0, sizeof(FILEINFO)); |
|
// save access mode |
fileinfo->mode = mode; |
|
// Get a local copy of the path. If it's longer than MAX_PATH, abort. |
strcpy2((char *) tmppath, (char *) path); |
tmppath[MAX_PATH - 1] = 0; |
if (strcmp2((char *) path,(char *) tmppath)) { |
return DFS_PATHLEN; |
} |
|
|
// strip leading path separators |
while (tmppath[0] == DIR_SEPARATOR) |
strcpy2((char *) tmppath, (char *) tmppath + 1); |
|
// Parse filename off the end of the supplied path |
p = tmppath; |
while (*(p++)); |
|
p--; |
while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix |
p--; |
if (*p == DIR_SEPARATOR) |
p++; |
|
DFS_CanonicalToDir(filename, p); |
|
if (p > tmppath) |
p--; |
if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix |
*p = 0; |
|
// At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE EXT" and |
// tmppath = "MYDIR/MYDIR2". |
di.scratch = scratch; |
if (DFS_OpenDir(volinfo, tmppath, &di)) |
return DFS_NOTFOUND; |
|
while (!DFS_GetNext(volinfo, &di, &de)) { |
|
if (!memcmp2(de.name, filename, 11)) { |
// You can't use this function call to open a directory. |
if (de.attr & ATTR_DIRECTORY) |
return DFS_NOTFOUND; |
printf("get enxt \n"); |
fileinfo->volinfo = volinfo; |
fileinfo->pointer = 0; |
// The reason we store this extra info about the file is so that we can |
// speedily update the file size, modification date, etc. on a file that is |
// opened for writing. |
if (di.currentcluster == 0) |
fileinfo->dirsector = volinfo->rootdir + di.currentsector; |
else |
fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; |
fileinfo->diroffset = di.currententry - 1; |
if (volinfo->filesystem == FAT32) { |
fileinfo->cluster = (unsigned long int) de.startclus_l_l | |
((unsigned long int) de.startclus_l_h) << 8 | |
((unsigned long int) de.startclus_h_l) << 16 | |
((unsigned long int) de.startclus_h_h) << 24; |
} |
else { |
fileinfo->cluster = (unsigned long int) de.startclus_l_l | |
((unsigned long int) de.startclus_l_h) << 8; |
} |
fileinfo->firstcluster = fileinfo->cluster; |
fileinfo->filelen = (unsigned long int) de.filesize_0 | |
((unsigned long int) de.filesize_1) << 8 | |
((unsigned long int) de.filesize_2) << 16 | |
((unsigned long int) de.filesize_3) << 24; |
|
return DFS_OK; |
} |
} |
|
// At this point, we KNOW the file does not exist. If the file was opened |
// with write access, we can create it. |
if (mode & DFS_WRITE) { |
unsigned long int cluster, temp; |
|
// Locate or create a directory entry for this file |
if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de)) |
return DFS_ERRMISC; |
|
// put sane values in the directory entry |
memset(&de, 0, sizeof(de)); |
memcpy(de.name, filename, 11); |
de.crttime_l = 0x20; // 01:01:00am, Jan 1, 2006. |
de.crttime_h = 0x08; |
de.crtdate_l = 0x11; |
de.crtdate_h = 0x34; |
de.lstaccdate_l = 0x11; |
de.lstaccdate_h = 0x34; |
de.wrttime_l = 0x20; |
de.wrttime_h = 0x08; |
de.wrtdate_l = 0x11; |
de.wrtdate_h = 0x34; |
|
// allocate a starting cluster for the directory entry |
cluster = DFS_GetFreeFAT(volinfo, scratch); |
|
de.startclus_l_l = cluster & 0xff; |
de.startclus_l_h = (cluster & 0xff00) >> 8; |
de.startclus_h_l = (cluster & 0xff0000) >> 16; |
de.startclus_h_h = (cluster & 0xff000000) >> 24; |
|
// update FILEINFO for our caller's sake |
fileinfo->volinfo = volinfo; |
fileinfo->pointer = 0; |
// The reason we store this extra info about the file is so that we can |
// speedily update the file size, modification date, etc. on a file that is |
// opened for writing. |
if (di.currentcluster == 0) |
fileinfo->dirsector = volinfo->rootdir + di.currentsector; |
else |
fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; |
fileinfo->diroffset = di.currententry - 1; |
fileinfo->cluster = cluster; |
fileinfo->firstcluster = cluster; |
fileinfo->filelen = 0; |
|
// write the directory entry |
// note that we no longer have the sector containing the directory entry, |
// tragically, so we have to re-read it |
if (DFS_ReadSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) |
return DFS_ERRMISC; |
memcpy(&(((PDIRENT) scratch)[di.currententry-1]), &de, sizeof(DIRENT)); |
if (DFS_WriteSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) |
return DFS_ERRMISC; |
|
// Mark newly allocated cluster as end of chain |
switch(volinfo->filesystem) { |
case FAT12: cluster = 0xff8; break; |
case FAT16: cluster = 0xfff8; break; |
case FAT32: cluster = 0x0ffffff8; break; |
default: return DFS_ERRMISC; |
} |
temp = 0; |
DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster, cluster); |
|
return DFS_OK; |
} |
|
return DFS_NOTFOUND; |
} |
|
/* |
Read an open file |
You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a |
pointer to a SECTOR_SIZE scratch buffer. |
Note that returning DFS_EOF is not an error condition. This function updates the |
successcount field with the number of bytes actually read. |
*/ |
unsigned long int DFS_ReadFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len) |
{ |
unsigned long int remain; |
unsigned long int result = DFS_OK; |
unsigned long int sector; |
unsigned long int bytesread; |
|
// Don't try to read past EOF |
if (len > fileinfo->filelen - fileinfo->pointer) |
len = fileinfo->filelen - fileinfo->pointer; |
|
remain = len; |
*successcount = 0; |
|
while (remain && result == DFS_OK) { |
// This is a bit complicated. The sector we want to read is addressed at a cluster |
// granularity by the fileinfo->cluster member. The file pointer tells us how many |
// extra sectors to add to that number. |
sector = fileinfo->volinfo->dataarea + |
((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + |
div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; |
|
// Case 1 - File pointer is not on a sector boundary |
if (div(fileinfo->pointer, SECTOR_SIZE).rem) { |
|
unsigned short tempreadsize; |
|
|
// We always have to go through scratch in this case |
result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); |
|
// This is the number of bytes that we actually care about in the sector |
// just read. |
|
tempreadsize = SECTOR_SIZE - (div(fileinfo->pointer, SECTOR_SIZE).rem); |
|
|
// Case 1A - We want the entire remainder of the sector. After this |
// point, all passes through the read loop will be aligned on a sector |
// boundary, which allows us to go through the optimal path 2A below. |
if (remain >= tempreadsize) { |
memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), tempreadsize); |
bytesread = tempreadsize; |
buffer += tempreadsize; |
fileinfo->pointer += tempreadsize; |
remain -= tempreadsize; |
} |
// Case 1B - This read concludes the file read operation |
else { |
memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), remain); |
|
buffer += remain; |
fileinfo->pointer += remain; |
bytesread = remain; |
remain = 0; |
} |
} |
// Case 2 - File pointer is on sector boundary |
else { |
|
// Case 2A - We have at least one more full sector to read and don't have |
// to go through the scratch buffer. You could insert optimizations here to |
// read multiple sectors at a time, if you were thus inclined (note that |
// the maximum multi-read you could perform is a single cluster, so it would |
// be advantageous to have code similar to case 1A above that would round the |
// pointer to a cluster boundary the first pass through, so all subsequent |
// [large] read requests would be able to go a cluster at a time). |
if (remain >= SECTOR_SIZE) { |
|
result = DFS_ReadSector(fileinfo->volinfo->unit, buffer, sector, 1); |
|
remain -= SECTOR_SIZE; |
|
buffer += SECTOR_SIZE; |
|
fileinfo->pointer += SECTOR_SIZE; |
|
bytesread = SECTOR_SIZE; |
|
} |
// Case 2B - We are only reading a partial sector |
else { |
|
result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); |
memcpy(buffer, scratch, remain); |
buffer += remain; |
fileinfo->pointer += remain; |
bytesread = remain; |
remain = 0; |
} |
} |
|
*successcount += bytesread; |
|
|
// check to see if we stepped over a cluster boundary |
if (div(fileinfo->pointer - bytesread, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != |
div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { |
// An act of minor evil - we use bytesread as a scratch integer, knowing that |
// its value is not used after updating *successcount above |
|
bytesread = 0; |
|
if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || |
((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || |
((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) |
result = DFS_EOF; |
else |
fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &bytesread, fileinfo->cluster); |
} |
} |
|
|
return result; |
} |
|
/* |
Seek file pointer to a given position |
This function does not return status - refer to the fileinfo->pointer value |
to see where the pointer wound up. |
Requires a SECTOR_SIZE scratch buffer |
*/ |
void DFS_Seek(PFILEINFO fileinfo, unsigned long int offset, unsigned char *scratch) |
{ |
unsigned long int tempint; |
|
// larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling |
// Case 0a - Return immediately for degenerate case |
if (offset == fileinfo->pointer) { |
return; |
} |
|
// Case 0b - Don't allow the user to seek past the end of the file |
if (offset > fileinfo->filelen) { |
offset = fileinfo->filelen; |
// NOTE NO RETURN HERE! |
} |
|
// Case 1 - Simple rewind to start |
// Note _intentional_ fallthrough from Case 0b above |
if (offset == 0) { |
fileinfo->cluster = fileinfo->firstcluster; |
fileinfo->pointer = 0; |
return; // larwe 9/16/06 +1 bugfix |
} |
// Case 2 - Seeking backwards. Need to reset and seek forwards |
else if (offset < fileinfo->pointer) { |
fileinfo->cluster = fileinfo->firstcluster; |
fileinfo->pointer = 0; |
// NOTE NO RETURN HERE! |
} |
|
// Case 3 - Seeking forwards |
// Note _intentional_ fallthrough from Case 2 above |
|
// Case 3a - Seek size does not cross cluster boundary - |
// very simple case |
// larwe 9/16/06 changed .rem to .quot in both div calls, bugfix |
if (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot == |
div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { |
fileinfo->pointer = offset; |
} |
// Case 3b - Seeking across cluster boundary(ies) |
else { |
// round file pointer down to cluster boundary |
fileinfo->pointer = div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot * |
fileinfo->volinfo->secperclus * SECTOR_SIZE; |
|
// seek by clusters |
// larwe 9/30/06 bugfix changed .rem to .quot in both div calls |
while (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != |
div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { |
|
fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &tempint, fileinfo->cluster); |
// Abort if there was an error |
if (fileinfo->cluster == 0x0ffffff7) { |
fileinfo->pointer = 0; |
fileinfo->cluster = fileinfo->firstcluster; |
return; |
} |
fileinfo->pointer += SECTOR_SIZE * fileinfo->volinfo->secperclus; |
} |
|
// since we know the cluster is right, we have no more work to do |
fileinfo->pointer = offset; |
} |
} |
|
/* |
Delete a file |
scratch must point to a sector-sized buffer |
*/ |
unsigned long int DFS_UnlinkFile(PVOLINFO volinfo, unsigned char *path, unsigned char *scratch) |
{ |
PDIRENT de = (PDIRENT) scratch; |
FILEINFO fi; |
unsigned long int cache = 0; |
unsigned long int tempclus; |
|
// DFS_OpenFile gives us all the information we need to delete it |
if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi)) |
return DFS_NOTFOUND; |
|
// First, read the directory sector and delete that entry |
if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1)) |
return DFS_ERRMISC; |
((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5; |
if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1)) |
return DFS_ERRMISC; |
|
// Now follow the cluster chain to free the file space |
while (!((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7) || |
(volinfo->filesystem == FAT16 && fi.firstcluster >= 0xfff7) || |
(volinfo->filesystem == FAT32 && fi.firstcluster >= 0x0ffffff7))) { |
tempclus = fi.firstcluster; |
|
fi.firstcluster = DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster); |
DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0); |
|
} |
return DFS_OK; |
} |
|
|
/* |
Write an open file |
You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a |
pointer to a SECTOR_SIZE scratch buffer. |
This function updates the successcount field with the number of bytes actually written. |
*/ |
unsigned long int DFS_WriteFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len) |
{ |
unsigned long int remain; |
unsigned long int result = DFS_OK; |
unsigned long int sector; |
unsigned long int byteswritten; |
|
// Don't allow writes to a file that's open as readonly |
if (!(fileinfo->mode & DFS_WRITE)) |
return DFS_ERRMISC; |
|
remain = len; |
*successcount = 0; |
|
while (remain && result == DFS_OK) { |
// This is a bit complicated. The sector we want to read is addressed at a cluster |
// granularity by the fileinfo->cluster member. The file pointer tells us how many |
// extra sectors to add to that number. |
sector = fileinfo->volinfo->dataarea + |
((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + |
div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; |
|
// Case 1 - File pointer is not on a sector boundary |
if (div(fileinfo->pointer, SECTOR_SIZE).rem) { |
unsigned short tempsize; |
printf("CASE 1 \n"); |
// We always have to go through scratch in this case |
result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); |
|
// This is the number of bytes that we don't want to molest in the |
// scratch sector just read. |
tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem; |
|
// Case 1A - We are writing the entire remainder of the sector. After |
// this point, all passes through the read loop will be aligned on a |
// sector boundary, which allows us to go through the optimal path |
// 2A below. |
if (remain >= SECTOR_SIZE - tempsize) { |
memcpy(scratch + tempsize, buffer, SECTOR_SIZE - tempsize); |
if (!result) |
result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); |
|
byteswritten = SECTOR_SIZE - tempsize; |
buffer += SECTOR_SIZE - tempsize; |
fileinfo->pointer += SECTOR_SIZE - tempsize; |
if (fileinfo->filelen < fileinfo->pointer) { |
fileinfo->filelen = fileinfo->pointer; |
} |
remain -= SECTOR_SIZE - tempsize; |
} |
// Case 1B - This concludes the file write operation |
else { |
printf("CASE 1B \n"); |
memcpy(scratch + tempsize, buffer, remain); |
if (!result) |
result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); |
|
buffer += remain; |
fileinfo->pointer += remain; |
if (fileinfo->filelen < fileinfo->pointer) { |
fileinfo->filelen = fileinfo->pointer; |
} |
byteswritten = remain; |
remain = 0; |
} |
} // case 1 |
// Case 2 - File pointer is on sector boundary |
else { |
printf("CASE 2 \n"); |
// Case 2A - We have at least one more full sector to write and don't have |
// to go through the scratch buffer. You could insert optimizations here to |
// write multiple sectors at a time, if you were thus inclined. Refer to |
// similar notes in DFS_ReadFile. |
if (remain >= SECTOR_SIZE) { |
result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); |
remain -= SECTOR_SIZE; |
buffer += SECTOR_SIZE; |
fileinfo->pointer += SECTOR_SIZE; |
if (fileinfo->filelen < fileinfo->pointer) { |
fileinfo->filelen = fileinfo->pointer; |
} |
byteswritten = SECTOR_SIZE; |
} |
// Case 2B - We are only writing a partial sector and potentially need to |
// go through the scratch buffer. |
else { |
printf("CASE 2B \n"); |
// If the current file pointer is not yet at or beyond the file |
// length, we are writing somewhere in the middle of the file and |
// need to load the original sector to do a read-modify-write. |
if (fileinfo->pointer < fileinfo->filelen) { |
result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); |
if (!result) { |
memcpy(scratch, buffer, remain); |
result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); |
} |
} |
else { |
result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); |
} |
|
buffer += remain; |
fileinfo->pointer += remain; |
if (fileinfo->filelen < fileinfo->pointer) { |
fileinfo->filelen = fileinfo->pointer; |
} |
byteswritten = remain; |
remain = 0; |
} |
} |
|
*successcount += byteswritten; |
printf("Writen byte %d \n", *successcount ); |
// check to see if we stepped over a cluster boundary |
if (div(fileinfo->pointer - byteswritten, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != |
div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { |
unsigned long int lastcluster; |
|
// We've transgressed into another cluster. If we were already at EOF, |
// we need to allocate a new cluster. |
// An act of minor evil - we use byteswritten as a scratch integer, knowing |
// that its value is not used after updating *successcount above |
byteswritten = 0; |
|
lastcluster = fileinfo->cluster; |
fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster); |
|
// Allocate a new cluster? |
if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || |
((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || |
((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) { |
unsigned long int tempclus; |
|
tempclus = DFS_GetFreeFAT(fileinfo->volinfo, scratch); |
byteswritten = 0; // invalidate cache |
if (tempclus == 0x0ffffff7) |
return DFS_ERRMISC; |
|
// Link new cluster onto file |
DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, lastcluster, tempclus); |
fileinfo->cluster = tempclus; |
|
// Mark newly allocated cluster as end of chain |
switch(fileinfo->volinfo->filesystem) { |
case FAT12: tempclus = 0xff8; break; |
case FAT16: tempclus = 0xfff8; break; |
case FAT32: tempclus = 0x0ffffff8; break; |
default: return DFS_ERRMISC; |
} |
DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster, tempclus); |
|
result = DFS_OK; |
} |
// No else clause is required. |
} |
} |
|
// Update directory entry |
if (DFS_ReadSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) |
return DFS_ERRMISC; |
((PDIRENT) scratch)[fileinfo->diroffset].filesize_0 = fileinfo->filelen & 0xff; |
((PDIRENT) scratch)[fileinfo->diroffset].filesize_1 = (fileinfo->filelen & 0xff00) >> 8; |
((PDIRENT) scratch)[fileinfo->diroffset].filesize_2 = (fileinfo->filelen & 0xff0000) >> 16; |
((PDIRENT) scratch)[fileinfo->diroffset].filesize_3 = (fileinfo->filelen & 0xff000000) >> 24; |
if (DFS_WriteSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) |
return DFS_ERRMISC; |
return result; |
} |
|
int memcmp2(const void* s1, const void* s2,size_t n) |
{ |
const unsigned char *p1 = s1, *p2 = s2; |
while(n--) |
if( *p1 != *p2 ) |
return *p1 - *p2; |
else |
*p1++,*p2++; |
return 0; |
} |
|
char *strcpy2(char *dest, char* src) |
{ |
char *ret = dest; |
while (*dest++ = *src++) |
; |
return ret; |
} |
|
int strcmp2(const char* s1, const char* s2) |
{ |
while(*s1 && (*s1==*s2)) |
s1++,s2++; |
return *(const unsigned char*)s1-*(const unsigned char*)s2; |
} |
orpmon/common/dosfs.c
Property changes :
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: orpmon/common/Makefile
===================================================================
--- orpmon/common/Makefile (revision 375)
+++ orpmon/common/Makefile (revision 389)
@@ -3,7 +3,7 @@
LIB = common_o.o
-OBJS = common.o support.o cprintf.o screen.o font.o ctype.o string.o spincursor.o
+OBJS = common.o support.o cprintf.o screen.o font.o ctype.o string.o spincursor.o dosfs.o
SOBJS = or32.o
all: $(LIB)
@@ -19,4 +19,4 @@
sinclude .depend
-#########################################################################
+
/orpmon/drivers/sdc.c
0,0 → 1,246
#include "sdc.h" |
volatile sd_card dev; |
|
void reset_card() |
{ |
SD_REG(SD_ARG) = 0; |
SD_REG(SD_COMMAND) = 0; |
return; |
} |
|
unsigned char sd_wait_rsp() |
{ |
volatile unsigned long r1, r2; |
|
//Polling for timeout and command complete |
while (1 ) |
{ |
r1= SD_REG(SD_ERROR_INT_STATUS); |
r2= SD_REG(SD_NORMAL_INT_STATUS); |
|
if (( r1 & CMD_TIMEOUT ) == CMD_TIMEOUT) |
return 0; |
else if ((r2 & CMD_COMPLETE ) == CMD_COMPLETE) |
return 1; |
|
} |
//Later Exception restart module |
return 0; |
|
} |
|
int setup_bd_transfer(boolean direction, int block_addr, volatile unsigned char *buff) |
{ |
int offset; |
int block_addr_sd; |
//debug("Read mmc_read_block %d to addr %d \n", block_number, buff_addr); |
// debug("read %d to addr %d \n", block_number, buff_addr); |
if (dev.phys_spec_2_0 && dev.cid_reg !=66848) |
block_addr_sd=block_addr; |
else |
block_addr_sd=(block_addr<<9); |
|
if (direction) |
{ |
SD_REG(BD_TX) = buff; |
SD_REG(BD_TX) = block_addr_sd; |
|
return TRUE; |
} |
else |
{ |
SD_REG(BD_RX) = buff; |
SD_REG(BD_RX) = block_addr_sd; |
return TRUE; |
} |
|
} |
|
int finnish_bd_transfer() |
{ |
volatile unsigned long rtn_reg=0; |
|
rtn_reg= SD_REG(BD_ISR); |
while ( rtn_reg==0 ){ |
rtn_reg= SD_REG(BD_ISR) ; |
} |
SD_REG(BD_ISR) =0; |
|
if ( rtn_reg & 0x1) |
{ |
DBGA("\n Data transfer succesful\n"); |
return TRUE; |
} |
else |
{ |
DBGA("Data transfer failed, rtn %x\n",rtn_reg); |
return FALSE; |
} |
} |
|
|
|
int sd_setup_transfer (sd_card sd_card_0) |
{ |
DBGA("Set up transfer\n"); |
|
//Put in transfer state |
SD_REG(SD_COMMAND) = CMD7 | CICE | CRCE | RSP_48; |
SD_REG(SD_ARG)=sd_card_0.rca | 0xf0f0; |
if (!sd_wait_rsp()){ |
DBGA("Go send failed TO:/!\n"); |
return FALSE; |
} |
else if ( SD_REG(SD_RESP1) == (CARD_STATUS_STB | READY_FOR_DATA ) ) |
DBGA("Ready to transfer data!\n"); |
else{ |
DBGA("Card not ready for data %x \n", SD_REG(SD_RESP1) ); |
return FALSE; |
} |
//Set block size |
|
if (!setBLockLength()) |
return FALSE; |
|
//Set Bus width to 4, CMD55 followed by ACMD 6 |
SD_REG(SD_COMMAND) = CMD55|RSP_48; |
SD_REG(SD_ARG) =sd_card_0.rca | 0xf0f0; |
if (!sd_wait_rsp()) |
{ |
DBGA("CMD55 send failed :/!\n"); |
return FALSE; |
} |
|
|
SD_REG(SD_COMMAND) = ACMD6 | CICE | CRCE | RSP_48; |
SD_REG(SD_ARG)=0x2; |
if (!sd_wait_rsp()) |
{ |
DBGA("ACMD6 send failed :/!\n"); |
return FALSE; |
} |
|
|
DBGA("Card Status reg ACMD6: 0x%x \n", SD_REG(SD_RESP1) ); |
DBGA("FREE BD TX/RX: 0x%x \n", SD_REG(BD_STATUS) ) ; |
DBGA("CARD in Transfer state\n"); |
return TRUE; |
|
} |
|
int setBLockLength(void){ |
|
SD_REG(SD_COMMAND) = CMD16 | CICE | CRCE | RSP_48; |
SD_REG(SD_ARG)=512; |
if (!sd_wait_rsp()){ |
DBGA("Set block size failed :/!\n"); |
return FALSE;} |
DBGA("Set block size to 512 Succes, resp 0x%x \n", SD_REG(SD_RESP1)); |
return TRUE; |
} |
int memCardInit(void) |
{ |
|
volatile unsigned long rtn_reg=0; |
volatile unsigned long rtn_reg1=0; |
|
|
SD_REG(SD_TIMEOUT)=0x28FF; |
SD_REG(SD_SOFTWARE_RST)=1; |
|
SD_REG(SD_CLOCK_D) =0; |
SD_REG(SD_SOFTWARE_RST)=0; |
|
reset_card(); |
sd_wait_rsp(); |
DBGA("sd reset \n"); |
|
SD_REG(SD_COMMAND) = ( CMD8 | CICE | CRCE | RSP_48); |
SD_REG(SD_ARG) = VHS|CHECK_PATTERN; |
|
dev.phys_spec_2_0 = sd_wait_rsp(); |
reset_card; |
sd_wait_rsp(); |
if (dev.phys_spec_2_0) |
{ |
|
rtn_reg=0; |
while ((rtn_reg & BUSY) != BUSY) |
{ |
SD_REG(SD_COMMAND) = CMD55|RSP_48; |
SD_REG(SD_ARG) =0; |
if (!sd_wait_rsp()) |
return FALSE; |
|
SD_REG(SD_COMMAND) =ACMD41 | RSP_48; |
SD_REG(SD_ARG) = 0x40000000 | 0xFF8000; |
if (!sd_wait_rsp()) |
return FALSE; |
|
rtn_reg= SD_REG(SD_RESP1); |
} |
dev.Voltage_window=rtn_reg&VOLTAGE_MASK; |
dev.HCS_s = 0; |
|
} |
else |
{ |
DBGA("SDC 1.xx card \n"); |
SD_REG(SD_ARG) =0x0000; |
SD_REG(SD_COMMAND) =0x0000; |
while (REG32(SDC_CONTROLLER_BASE+SD_STATUS)& 1) {} |
|
rtn_reg=0; |
|
while ((rtn_reg & BUSY) != BUSY) |
{ |
SD_REG(SD_COMMAND) = CMD55|RSP_48; |
SD_REG(SD_ARG) = 0; |
if (!sd_wait_rsp()) |
{ |
rtn_reg= SD_REG(SD_RESP1) ; |
DBGA("FAIL rtn CMD55 %x\n", rtn_reg); |
return FALSE; |
} |
SD_REG(SD_COMMAND) =ACMD41 | RSP_48; |
SD_REG(SD_ARG) = 0; |
if (!sd_wait_rsp()) |
{ |
rtn_reg= SD_REG(SD_RESP1) ; |
DBGA("FAIL rtn ACMD41 %x\n", rtn_reg); |
return FALSE; |
} |
rtn_reg= SD_REG(SD_RESP1) ; |
DBGA("rtn ACMD41 %x\n", rtn_reg); |
} |
dev.Voltage_window=rtn_reg&VOLTAGE_MASK; |
dev.HCS_s = 0; |
|
} |
DBGA("get cid \n"); |
SD_REG(SD_COMMAND) =CMD2 | RSP_146; |
SD_REG(SD_ARG) =0; |
if (!sd_wait_rsp()) |
return FALSE; |
|
DBGA("get rca \n"); |
SD_REG(SD_COMMAND) = CMD3 | CICE | CRCE | RSP_48; |
SD_REG(SD_ARG) = 0; |
if (!sd_wait_rsp()){ |
DBGA("rca failed \n"); |
return FALSE; |
} |
rtn_reg = SD_REG(SD_RESP1); |
dev.rca = ((rtn_reg&RCA_RCA_MASK)); |
|
SD_REG(SD_COMMAND) = CMD9 | RSP_146; |
SD_REG(SD_ARG)=0; |
if (!sd_wait_rsp()) |
DBGA("NO CID! \n"); |
dev.cid_reg = SD_REG(SD_RESP1); |
|
dev.Active=1; |
return sd_setup_transfer(dev); |
|
|
} |
/orpmon/drivers/Makefile
1,7 → 1,7
|
LIB = drivers.o |
#OBJS = int.o eth.o uart.o tick.o flash.o keyboard.o spi.o ata.o smc91111.o |
OBJS = int.o eth.o uart.o tick.o #flash.o keyboard.o spi.o ata.o smc91111.o |
OBJS = int.o eth.o sdc.o uart.o tick.o #flash.o keyboard.o spi.o ata.o smc91111.o |
|
all: $(LIB) |
|