osd-contiki/backyard/platform/c64/loader/c64-fs.c

412 lines
12 KiB
C

/**
* \defgroup c64fs C64 file system and disk functions.
* @{
*
* The C64 file system functions are divided into two categories:
* those that deal with C64 files and the C64 disk directory, and
* those that allow direct block access to the disk. The former
* functions can be used for accessing regular files, whereas the
* latter functions are used e.g. to download D64 files onto 1541
* disks.
*
* \note The C64 filesystem functions currently only work with the
* 1541/1541-II/1571 and compatible drives, and not with the IDE64
* hard disks or the 1581/FD2000 3.5" drives.
*
*
*/
/**
* \file
* C64 file system operations interface for Contiki.
* \author Adam Dunkels <adam@dunkels.com>
*
*/
/*
* Copyright (c) 2003, Adam Dunkels.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki desktop environment
*
* $Id: c64-fs.c,v 1.1 2007/05/23 23:11:28 oliverschmidt Exp $
*
*/
#include "c64-dio.h"
#include "c64-dio-asm.h"
#include "c64-fs.h"
#include <string.h>
#include <stdio.h>
struct directory_entry {
unsigned char type;
unsigned char track, sect;
unsigned char name[16];
unsigned char reltrack, relsect, relreclen;
unsigned char unused1, unused2, unused3, unused4;
unsigned char tmptrack, tmpsect;
unsigned char blockslo, blockshi;
};
unsigned char _c64_fs_dirbuf[256];
unsigned char _c64_fs_dirbuftrack = 0, _c64_fs_dirbufsect = 0;
unsigned char _c64_fs_filebuf[256];
unsigned char _c64_fs_filebuftrack = 0, _c64_fs_filebufsect = 0;
static struct c64_fs_dirent lastdirent;
static struct c64_fs_dir opendir;
static struct c64_fs_dirent opendirent;
/*-----------------------------------------------------------------------------------*/
/**
* Open a file.
*
* The file description must be allocated by the caller and a pointer
* to it is passed to this function.
*
* \param name A pointer to the name of the file to be opened.
* \param f A pointer to the file descriptor struct.
*
* \retval 0 If the file was successfully opened.
* \retval -1 If the file does not exist.
*/
/*-----------------------------------------------------------------------------------*/
int
c64_fs_open(const char *name, register struct c64_fs_file *f)
{
/* First check if we already have the file cached. If so, we don't
need to do an expensive directory lookup. */
if(strncmp(lastdirent.name, name, 16) == 0) {
f->track = lastdirent.track;
f->sect = lastdirent.sect;
f->ptr = 2;
return 0;
}
/* Not in cache, so we walk through directory instead. */
c64_fs_opendir(&opendir);
do {
c64_fs_readdir_dirent(&opendir, &opendirent);
if(strncmp(opendirent.name, name, 16) == 0) {
f->track = opendirent.track;
f->sect = opendirent.sect;
f->ptr = 2;
return 0;
}
} while(c64_fs_readdir_next(&opendir) == 0);
/* The file was not found in the directory. We flush the directory
buffer cache now in order to prevent a nasty problem from
happening: If the first directory block of an empty disk was
cached, *all* subsequent file opens would return "file not
found". */
_c64_fs_dirbuftrack = 0; /* There are no disk blocks on track 0. */
return -1;
}
/*-----------------------------------------------------------------------------------*/
/**
* Read data from an open file.
*
* This function reads data from an open file into a buffer than must
* be allocated by the caller.
*
* \param f A pointer to a file descriptor structure that must have
* been opened with c64_fs_open().
*
* \param buf A pointer to the buffer in which the data should be placed.
*
* \param len The maxiumum amount of bytes to read.
*
* \return The number of bytes that actually was read, or 0 if an end
* of file was encountered.
*/
/*-----------------------------------------------------------------------------------*/
#if !NOASM
#pragma optimize(push, off)
#endif /* !NOASM */
int __fastcall__
c64_fs_read(register struct c64_fs_file *f, char *buf, int len)
{
static int i;
/* Check if current block is already in buffer, and if not read it
from disk. */
#if NOASM
if(f->track != _c64_fs_filebuftrack ||
_c64_fs_filebufsect != f->sect) {
_c64_fs_filebuftrack = f->track;
_c64_fs_filebufsect = f->sect;
c64_dio_read_block(_c64_fs_filebuftrack, _c64_fs_filebufsect,
_c64_fs_filebuf);
}
#else /* NOASM */
asm("ldy #%b", offsetof(struct c64_fs_file, track));
asm("lda (regbank+%b),y", 4);
asm("cmp %v", _c64_fs_filebuftrack);
asm("bne doblock");
asm("ldy #%b", offsetof(struct c64_fs_file, sect));
asm("lda (regbank+%b),y", 4);
asm("cmp %v", _c64_fs_filebufsect);
asm("bne doblock");
asm("jmp noblock");
asm("doblock:");
asm("ldy #%b", offsetof(struct c64_fs_file, track));
asm("lda (regbank+%b),y", 4);
asm("sta %v", _c64_fs_filebuftrack);
asm("sta %v", c64_dio_asm_track);
asm("ldy #%b", offsetof(struct c64_fs_file, sect));
asm("lda (regbank+%b),y", 4);
asm("sta %v", _c64_fs_filebufsect);
asm("sta %v", c64_dio_asm_sector);
asm("lda #<(%v)", _c64_fs_filebuf);
asm("sta %v", c64_dio_asm_ptr);
asm("lda #>(%v)", _c64_fs_filebuf);
asm("sta %v+1", c64_dio_asm_ptr);
asm("jsr %v", c64_dio_asm_read_block);
asm("noblock:");
#endif /* NOASM */
if(_c64_fs_filebuf[0] == 0 &&
f->ptr == _c64_fs_filebuf[1]) {
return 0; /* EOF */
}
for(i = 0; i < len; ++i) {
#if NOASM
*buf = _c64_fs_filebuf[f->ptr];
++f->ptr;
#else /* NOASM */
asm("ldy #%o+1", buf);
asm("jsr ldaxysp");
asm("sta ptr2");
asm("stx ptr2+1");
asm("ldy #%b", offsetof(struct c64_fs_file, ptr));
asm("lda (regbank+%b),y", 4);
asm("tax");
asm("ldy #0");
asm("lda %v,x", _c64_fs_filebuf);
asm("sta (ptr2),y");
asm("inx");
asm("txa");
asm("ldy #%b", offsetof(struct c64_fs_file, ptr));
asm("sta (regbank+%b),y", 4);
#endif /* NOASM */
if(_c64_fs_filebuf[0] == 0) {
if(f->ptr == _c64_fs_filebuf[1]) {
/* End of file reached, we return the amount of bytes read so
far. */
return i + 1;
}
} else if(f->ptr == 0) {
/* Read new block into buffer and set buffer state
accordingly. */
_c64_fs_filebuftrack = f->track = _c64_fs_filebuf[0];
_c64_fs_filebufsect = f->sect = _c64_fs_filebuf[1];
f->ptr = 2;
c64_dio_read_block(_c64_fs_filebuftrack,
_c64_fs_filebufsect, _c64_fs_filebuf);
}
++buf;
}
return i;
}
#if !NOASM
#pragma optimize(pop)
#endif /* !NOASM */
/*-----------------------------------------------------------------------------------*/
/**
* Close an open file.
*
* \param f A pointer to a file descriptor struct that previously has
* been opened with c64_fs_open().
*/
/*-----------------------------------------------------------------------------------*/
void
c64_fs_close(struct c64_fs_file *f)
{
}
/*-----------------------------------------------------------------------------------*/
/**
* \internal
* Read a directory buffer into the _c64_fs_dirbuf buffer.
*
* This function is shared between this and the c64-fs-raw module.
*
* \param track The track of the directory block.
* \param sect The sector of the directory block.
*/
/*-----------------------------------------------------------------------------------*/
void
_c64_fs_readdirbuf(unsigned char track, unsigned char sect)
{
if(_c64_fs_dirbuftrack == track &&
_c64_fs_dirbufsect == sect) {
/* Buffer already contains requested block, return. */
return;
}
c64_dio_read_block(track, sect, _c64_fs_dirbuf);
_c64_fs_dirbuftrack = track;
_c64_fs_dirbufsect = sect;
}
/*-----------------------------------------------------------------------------------*/
/**
* Open the disk directory for reading.
*
* The caller must supply a pointer to a directory descriptor.
*
* \param d A pointer to a directory description that must be
* allocated by the caller.
*/
/*-----------------------------------------------------------------------------------*/
unsigned char
c64_fs_opendir(register struct c64_fs_dir *d)
{
d->track = 18;
d->sect = 1;
d->ptr = 2;
return 0;
}
/*-----------------------------------------------------------------------------------*/
/**
* Read the current directory entry.
*
* This function reads the directory entry to which the directory
* descriptor currently points into a struct c64_fs_dirent supplied by
* the caller.
*
* The function c64_fs_readdir_next() is used to move the directory
* entry pointer forward in the directory.
*
* \param d A pointer to a directory descriptor previously opened with c64_fs_opendir().
*
* \param f A pointer to a directory entry that must have been
* previously allocated by the caller.
*/
/*-----------------------------------------------------------------------------------*/
void
c64_fs_readdir_dirent(register struct c64_fs_dir *d,
register struct c64_fs_dirent *f)
{
struct directory_entry *de;
int i;
register char *nameptr;
_c64_fs_readdirbuf(d->track, d->sect);
de = (struct directory_entry *)&_c64_fs_dirbuf[d->ptr];
nameptr = de->name;
for(i = 0; i < 16; ++i) {
if(*nameptr == 0xa0) {
*nameptr = 0;
break;
}
++nameptr;
}
strncpy(f->name, de->name, 16);
f->track = de->track;
f->sect = de->sect;
f->size = de->blockslo + (de->blockshi >> 8);
memcpy(&lastdirent, f, sizeof(struct c64_fs_dirent));
}
/*-----------------------------------------------------------------------------------*/
/**
* Move the directory pointer forward.
*
* This function moves the directory entry pointer in the directory
* descriptor forward so that it points to the next file.
*
* \param d A pointer to a directory descriptor previously opened with
* c64_fs_opendir().
*
* \retval 1 If there are no more directory entried in the directory.
* \retval 0 There were more directory entries and the pointer has
* been moved to point to the next one.
*/
/*-----------------------------------------------------------------------------------*/
unsigned char
c64_fs_readdir_next(struct c64_fs_dir *d)
{
struct directory_entry *de;
again:
_c64_fs_readdirbuf(d->track, d->sect);
if(d->ptr == 226) {
if(_c64_fs_dirbuf[0] == 0) {
return 1;
}
d->track = _c64_fs_dirbuf[0];
d->sect = _c64_fs_dirbuf[1];
d->ptr = 2;
} else {
d->ptr += 32;
}
de = (struct directory_entry *)&_c64_fs_dirbuf[d->ptr];
if(de->type == 0) {
goto again;
}
return 0;
}
/*-----------------------------------------------------------------------------------*/
/**
* Close a directory descriptor previously opened by c64_fs_opendir().
*
* \param d A poitner to a directory descriptor previously opened with
* c64_fs_opendir().
*/
/*-----------------------------------------------------------------------------------*/
void
c64_fs_closedir(struct c64_fs_dir *d)
{
}
/*-----------------------------------------------------------------------------------*/
/** @} */