Subversion Repositories openrisc_2011-10-31

/*
    dos.c -- provides simple access to FAT (dos) partitions
    Copyright (C) 2002 Richard Herveille, rherveille@opencores.org
 
    This file is part of OpenRISC 1000 Reference Platform Monitor (ORPmon)
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
 
//#include "common.h"
 
#include <stddef.h>
#include <string.h>
#include "dos.h"
#include "ata.h"
 
/*
  D O S _ O P E N
*/
int dos_open(struct dosparam *params)
{
	int error, start_sector, partition;
	unsigned char buf[512];
 
	struct inode *inode = &params->inode;
	struct file *filp = &params->filp;
	struct request *request = &params->request;
 
	if ((error = ata_open(inode, filp)))
		return error;
 
	/* device opened, read MBR                                          */
	request->cmd = READ;
	request->sector = 0;
	request->nr_sectors = 1;
	request->buffer = buf;
 
	/* skip bootload (446) bytes                                        */
	/* currently only support the first partition (partition 4)         */
	/* This is OK, because CompactFLASH devices only have 1 partition   */
	if ((error = ata_request(inode, filp, request)))
		return error;
 
	partition = 0;		/* first partition                                */
	partition *= 16;	/* 16 bytes per partition table                   */
	partition += 446;	/* skip bootloader, go to partition table         */
	start_sector = buf[partition + 11] << 24 |
	    buf[partition + 10] << 16 |
	    buf[partition + 9] << 8 | buf[partition + 8];
 
	/* device opened, read boot-sector                                  */
	request->cmd = READ;
	request->sector = start_sector;
	request->nr_sectors = 1;
	request->buffer = buf;
 
	if ((error = ata_request(inode, filp, request)))
		return error;
 
	/* get the necessary data from the boot-sector                      */
	params->bytes_per_sector = (buf[12] << 8) | buf[11];
	params->fats = buf[16];
	params->sectors_per_fat = (buf[23] << 8) | buf[22];
	params->root_entries = (buf[18] << 8) | buf[17];
	params->sectors_per_cluster = buf[13];
 
	/* set start of current directory to start of root-directory        */
	params->ssector =
	    start_sector + params->fats * params->sectors_per_fat + 1;
 
	/* set current sector to start of root-directory                    */
	params->csector = params->ssector;
 
	/* set start-entry number                                           */
	params->sentry = 0;
 
	return 0;
}
 
/*
  D O S _ R E L E A S E
*/
int dos_release(struct dosparam *params)
{
	return 0;
}
 
/*
  D O S _ N A M E C M P
*/
int dos_namecmp(const char *sname, const char *name, const char *ext)
{
	char fname[9], fext[4], *p;
 
	/* filename :                                                       */
	/* copy the filename                                                */
	strncpy(fname, sname, 8);
 
	/* check if we copied the '.' already, if so terminate string       */
	if ((p = strchr(fname, '.')))
		*p = '\0';
 
	/* fill remaining chars with ' '                                    */
	strncat(fname, "        ", 8 - strlen(fname));
 
	fname[9] = '\0';
 
	/* file-extension                                                   */
	/* search for the '.' in the filename                               */
	if ((p = strchr(sname, '.')))
		strncpy(fext, p, 3);
	else
		fext[0] = fext[1] = fext[2] = ' ';
 
	fext[4] = '\0';
 
	return (strcmp(fname, name) && strcmp(fext, ext));
}
 
/*
  D O S _ D I R _ F I N D _ E N T R Y
*/
struct dos_dir_entry *dos_dir_find_entry(struct dosparam *params,
					 const char *name)
{
	struct dos_dir_entry *entry;
	unsigned long entry_no = 0;
 
	/* go to start of current directory                                 */
	if (params->csector != params->ssector)
		dos_dir_cluster_reset(params);
 
	/* search for the requested entry                                   */
	while ((entry = dos_dir_get_entry(params, entry_no))
	       && dos_namecmp(name, entry->name, entry->ext))
		entry_no++;
 
	return entry;
}
 
/*
  D O S _ D I R _ G E T _ E N T R Y
*/
struct dos_dir_entry *dos_dir_get_entry(struct dosparam *params,
					unsigned long entry)
{
	char *buf = params->cbuf;
 
	if (entry < params->sentry)
		buf = dos_dir_cluster_reset(params);
 
	while (entry >= (params->sentry + entries_per_cluster(params)))
		if (!(buf = dos_dir_cluster_read_nxt(params)))
			return NULL;
 
	return (struct dos_dir_entry *)(buf +
					((entry -
					  params->sentry) *
					 sizeof(struct dos_dir_entry)));
}
 
/*
  D O S _ R E A D _ C L U S T E R
*/
char *dos_read_cluster(struct dosparam *params, unsigned long ssector)
{
	int error;
 
	struct inode *inode = &params->inode;
	struct file *filp = &params->filp;
	struct request *request = &params->request;
 
	request->cmd = READ;
	request->sector = ssector;
	request->nr_sectors = params->sectors_per_cluster;
	request->buffer = params->cbuf;
 
	if ((error = ata_request(inode, filp, request)))
		return NULL;
 
	params->csector = ssector;
 
	return params->cbuf;
}
 
/*
  D O S _ D I R _ C L U S T E R _ R E A D _ N X T
*/
char *dos_dir_cluster_read_nxt(struct dosparam *params)
{
	char *p;
	unsigned long nxt_cluster_start;
 
	/* TODO: add FAT lookup */
 
	nxt_cluster_start = params->csector + params->sectors_per_cluster;
 
	if (!(p = dos_read_cluster(params, nxt_cluster_start)))
		return NULL;
 
	params->sentry += entries_per_cluster(params);
 
	return p;
}
 
/*
  D O S _ D I R _ C L U S T E R _ R E S E T
*/
char *dos_dir_cluster_reset(struct dosparam *params)
{
	params->sentry = 0;
	return dos_read_cluster(params, params->ssector);
}