fs2.c

KaOS is a real-time operating system that has been implemented with the basic real-time constraints

void formatsd(mmc_csd *csd, UCHAR buffer[512])
{
    // csd->sectors
    // csd->blocksize
    // blocksize * sectors = capacity
    
    register int i, j, tocLength, statusLength;
    
    tocLength = csd->sectors / (512);
    statusLength = csd->sectors / 512 / 8;
    
    for (i = 0; i < tocLength; ++i)
    {
        mmc_write_sector(512*i, buffer);
    }
    for (i = 0; i < csd->sectors; ++i)
    {
        if (i < tocLength+(csd->sectors / 512 / 8))
        {
            buffer[(i/8)%4096] |= 1 << (8-(i % 8));
        }
        else
        {
            buffer[(i/8)%4096] &= (0xFF ^ (1 << (8-(i % 8))));
        }
        if (i == 4096)
        {
            mmc_write_sector(512*(i/4096 + tocLength), buffer);
            j = i / 4096;
        }
    }
    if (i % 4096)
    {
        for (i = i % 4096; i < 4096; ++i)
        {
            buffer[(i/8)%4096] &= (0xFF ^ (1 << (8-(i % 8))));
        }
        mmc_write_sector(512*(j + 1 + tocLength), buffer);
    }
}
ULONG alloc_sector(mmc_csd *csd, UCHAR buffer[512])
{
    // we need to search the sector usage table and find the first 0
    // mmk?
    
    register int i, tocLength, statusLength;

    if (csd->sectors % 4096)
    {
        statusLength = (csd->sectors+4096) / 512 / 8;
    }
    tocLength = csd->sectors / (512);

    for (i = 0; i < csd->sectors; ++i)
    {
        if (i % 4096 == 0)
        {
            mmc_read_sector((tocLength + i/4096)*512, buffer);
        }
        if (!(buffer[i/8] & (1 << (8-(i%8)))))
        {
            buffer[(i/8)%4096] |= 1 << (8-(i % 8));
            mmc_write_sector((tocLength + i/4096)*512, buffer);
            return (tocLength + i + statusLength)*512;
        }
    }
    return 0;
}

UCHAR dread(DIR *directory, FILE *file)
{
    register UINT i,j;
    FILE_DETAILS* fdetails;

    // loop through the table of contents

    for (j = (directory->address / 512); j < 2; ++j)
    {
        mmc_read_sector(MMC_BUFFER_LEN * j, file->buffer);
        
        for (i = (directory->address % 512); i < MMC_BUFFER_LEN; i += sizeof(FILE_DETAILS))
        {
            if (file->buffer[i] & 0x80)
            {
                // it's a valid file/directory
                if ((file->buffer[i] & 0x40) && (fdetails->directoryID & 0b00111111) == directory->directoryID)
                {
                    // it's a file
                	fdetails = &file->details;
                	memcpy(fdetails, &(file->buffer[i]), sizeof(FILE_DETAILS));
                	file->pointer = fdetails->address;
                	file->detailsaddr = i+MMC_BUFFER_LEN*j;

                	directory->address = j*512+i+sizeof(FILE_DETAILS);

                    return DREAD_OK;
            	}
            }
            else
            {
            	break;
            }
        }
    }
    return DREAD_ERROR;
}

UCHAR fopen(DIR *directory, FILE * file, UCHAR *filename, UCHAR mode)
{
    register UINT i,j;
    FILE_DETAILS* fdetails;
    
    ULONG startAddress = MMC_BUFFER_LEN*2;
    ULONG detailAddress = -1;
    // loop through the table of contents
    
    
    for (j = 0; j < 2; ++j)
    {
        mmc_read_sector(MMC_BUFFER_LEN * j, file->buffer);
        
        for (i = 0; i < MMC_BUFFER_LEN; i += sizeof(FILE_DETAILS))
        {
        	printf("%d - %d - %d\r\n", j, i, file->buffer[i]);
            if (file->buffer[i] & 0x80)
            {
                // it's a valid file/directory
                if (file->buffer[i] & 0x40)
                {
                    // it's a file
                	fdetails = &file->details;
                	memcpy(fdetails, &(file->buffer[i]), sizeof(FILE_DETAILS));
                	file->pointer = fdetails->address;
                	file->detailsaddr = i+MMC_BUFFER_LEN*j;	

                    if ((fdetails->directoryID & 0b00111111) == directory->directoryID)
                    {
                        // we found the right directory
                        if (0 == strcmp(filename, fdetails->name))
                        {
	                        return FILE_EXISTS;
						}
                    }
           			startAddress = max(startAddress,fdetails->address + fdetails->size);
            	}
            }
            else
            {
            	detailAddress = i+MMC_BUFFER_LEN*j;
            	j = 2;
            	break;
            }
        }
    }
    if (mode == FOPEN_CREATE)
    {
        if (detailAddress == -1)
        {
        	return FILE_NOSPACE;
        }
        if ((startAddress % MMC_BUFFER_LEN) != 0)
        {
        	startAddress = ((startAddress / MMC_BUFFER_LEN) + 1) * MMC_BUFFER_LEN;
        }
        fdetails = &file->details;
        fdetails->directoryID = directory->directoryID | 0b11000000;
        memcpy(fdetails->name, filename, sizeof(fdetails->name));
        fdetails->size = 0;
        fdetails->address = startAddress;
        
        memcpy(&(file->buffer[detailAddress % MMC_BUFFER_LEN]), fdetails, sizeof(FILE_DETAILS));
        file->detailsaddr = detailAddress;
        
        file->pointer = startAddress;
        
        // commit changes
        mmc_write_sector(j*MMC_BUFFER_LEN, file->buffer);
        return FILE_CREATED;
    }
    return FILE_NOT_FOUND;
}
UINT fread(FILE *file)
{
	FILE_DETAILS *fdetails;
	
	fdetails = &file->details;
	
	printf("details: %x - %x - %x\r\n", file->pointer, fdetails->size, fdetails->address);
	
    if ((file->pointer - fdetails->size) >= fdetails->address) return 0;
 
    mmc_read_sector(file->pointer, file->buffer);
    file->pointer += MMC_BUFFER_LEN;
    if ((file->pointer - fdetails->size) >= fdetails->address)
    {
    	printf("%c - %c - %c\r\n", file->buffer[0], file->buffer[1], file->buffer[2]);
        return (fdetails->size % MMC_BUFFER_LEN);
    }
    else
    {
        return MMC_BUFFER_LEN;
    }
}

UCHAR fputs(FILE *file, UCHAR *buffer, UINT length)
{
	register UINT i, j;
	FILE_DETAILS *fdetails;
	
	fdetails = &file->details;

	if (length > MMC_BUFFER_LEN)
	{
		return FPUTS_ERROR;
	}
	if (((file->pointer + length) / MMC_BUFFER_LEN) != (file->pointer / MMC_BUFFER_LEN))
	{
		// we have to write part of the file, commit, then write the rest
		j = 0;
		for (i = (file->pointer % MMC_BUFFER_LEN); i < MMC_BUFFER_LEN; ++i)
		{
			file->buffer[i] = buffer[j++];
		}
		mmc_write_sector(file->pointer % MMC_BUFFER_LEN, file->buffer);
		for (i = 0; i < (length - j); ++i)
		{
			file->buffer[i] = buffer[j++];
		}
	}
	else
	{
		j = 0;
		for (i = (file->pointer % MMC_BUFFER_LEN); i < length; ++i)
		{
			file->buffer[i] = buffer[j++];
		}
		printf("readdetails: %x - %x - %x\r\n", file->pointer, fdetails->size, fdetails->address);
    	printf("%c - %c - %c\r\n", file->buffer[0], file->buffer[1], file->buffer[2]);
	}
	file->pointer += length;
	if ((file->pointer - fdetails->address) > fdetails->size)
	{
		fdetails->size = file->pointer - fdetails->address;
	}
	return FPUTS_OK;
}
void fflush(FILE *file)
{
	mmc_write_sector(file->pointer - (file->pointer % MMC_BUFFER_LEN), file->buffer);
}

void fseek(FILE *file, UCHAR mode, UINT offset)
{
	FILE_DETAILS *fdetails;
	fdetails = &file->details;

    switch (mode)
    {
        case FSEEK_START :
            file->pointer = offset;
            break;
        case FSEEK_END :
            file->pointer = fdetails->address + fdetails->size - offset;
            break;
        default :
            file->pointer = file->pointer + offset;
            break;
    }
}
void fclose(FILE *file)
{
	fflush(file);
	mmc_read_sector(file->detailsaddr / MMC_BUFFER_LEN, file->buffer);
	memcpy(&file->buffer[file->detailsaddr % MMC_BUFFER_LEN], &file->details, sizeof(file->details));
	mmc_write_sector(file->detailsaddr / MMC_BUFFER_LEN, file->buffer);
}