/* write to the virtual tivo disk (ie. all partitions
concatenated) */
void mfs_write_sectors(void *buf, u32 sec, u32 count)
{
int i;
u64 start=0;
if (vserver != -1) {
vserver_write_sectors(buf, sec, count);
return;
}
sec = partition_remap(sec);
for (i=0; devs[i].dev; i++) {
if (sec < start + devs[i].sectors) break;
start += devs[i].sectors;
}
if (!devs[i].dev) {
fprintf(stderr,"Failed to map sector %d\n", sec);
exit(1);
}
if (verbose) {
fprintf(stderr, "mapped %d to %s/%d\n", sec, devs[i].dev, (int)(sec-start));
}
write_sectors(devs[i].fd, buf, sec-start, count);
}
void ATA_DEVICE::write_data(unsigned data)
{
if (!loaded()) return;
if ((reg.devhead ^ device_id) & 0x10)
return;
if (/* (reg.status & (STATUS_DRQ | STATUS_BSY)) != STATUS_DRQ ||*/ transptr >= transcount)
return;
*(unsigned short*)(transbf + transptr*2) = (unsigned short)data; transptr++;
if (transptr < transcount)
return;
// look to state, prepare next block
if (state == S_WRITE_SECTORS)
{
write_sectors();
return;
}
if (state == S_FORMAT_TRACK)
{
format_track();
return;
}
if (state == S_RECV_PACKET)
{
handle_atapi_packet();
return;
}
/* if (state == S_MODE_SELECT) { exec_mode_select(); return; } */
}
/**
* write_verify_sectors - write several sectors from disk
* @drive_info: driveinfo struct describing the disk
* @lba: Position to write
* @data: Buffer to write
* @size: Size of the buffer (number of sectors)
**/
int write_verify_sectors(struct driveinfo *drive_info,
const unsigned int lba,
const void *data, const int size)
{
char *rb = malloc(SECTOR * size);
int status;
if (write_sectors(drive_info, lba, data, size) == -1)
return -1; /* Write failure */
if (read_sectors(drive_info, rb, lba, size) == -1)
return -1; /* Readback failure */
status = memcmp(data, rb, SECTOR * size);
free(rb);
return status ? -1 : 0;
}
/*
* Perform a write of a sequence of blocks; return the number of blocks
* successfully sequentially written.
*/
static int64_t do_write(HANDLE hDrive, unsigned char * buffer, uint64_t tryout, uint64_t block_size,
blk_t current_block)
{
int64_t got;
if (v_flag > 1)
print_status();
/* Try the write */
got = write_sectors(hDrive, block_size, current_block, tryout, buffer);
if (got < 0)
got = 0;
if (got & 511)
uprintf("%sWeird value (%ld) in do_write\n", bb_prefix, got);
got /= block_size;
return got;
}
static void handle_bio(struct bio *bio)
{
if (bio->map.length % IDE_SECTOR_SIZE) {
finish_bio(bio, BIO_FAILED);
return;
}
char *page = page_addr(bio->map.page);
const unsigned long long lba = bio->map.sector;
const size_t count = bio->map.length / IDE_SECTOR_SIZE;
void *data = page + bio->map.offset;
const int rc = bio->dir == BIO_READ
? read_sectors(data, lba, count)
: write_sectors(data, lba, count);
finish_bio(bio, rc == 0 ? BIO_FINISHED : BIO_FAILED);
}
int main (void) {
int cmd_key, loop, reset;
scp = (sata_core *)(SATA_CORE_BASE);
scp->ctrl_reg = REG_CLEAR;
scp->cmd_reg = REG_CLEAR;
xil_printf("\n\r STATUS REG : %x\r\n", scp->status_reg);
// SATA CORE RESET
while ((scp->status_reg & SATA_LINK_READY) != SATA_LINK_READY) {
scp->ctrl_reg = SW_RESET;
xil_printf("\n\r ---GTX RESET--- \r\n");
scp->ctrl_reg = REG_CLEAR;
for(i=0; i<10000000; i++);
j = j+i;
xil_printf("\n\r STATUS REG : %x\r\n", scp->status_reg);
}
// SATA CORE RESET
xil_printf("\n\r ---Testing Sata Core--- \r\n");
while (loop != 51) {
// Read/Write Command
xil_printf("\n\rSelect Command: Read-(1) or Write-(2): \r\n");
cmd_key = uartstat[0];
while(cmd_key < '0' || cmd_key > '9') cmd_key = uartstat[0];
printf("\nKey:%d", cmd_key);
if(cmd_key == 49)
read_sectors(SECTOR_ADDRESS, NUM_SECTORS);
else {
write_sectors(SECTOR_ADDRESS, NUM_SECTORS);
}
xil_printf("\n\n\rExit(e)?: Press '3'\r\n");
loop = uartstat[0];
while(loop < '0' || loop > '9') loop = uartstat[0];
//scp->ctrl_reg = REG_CLEAR;
}
xil_printf("\n\n\r Done ! \r\n");
return 0;
}
/* May read/write the same sector many times, but compatible with existing ms-sys */
int write_data(FILE *fp, uint64_t Position,
const void *pData, uint64_t Len)
{
unsigned char aucBuf[MAX_DATA_LEN];
HANDLE hDrive = (HANDLE)fp->_ptr;
uint64_t SectorSize = (uint64_t)fp->_bufsiz;
uint64_t StartSector, EndSector, NumSectors;
Position += (uint64_t)fp->_cnt;
StartSector = Position/SectorSize;
EndSector = (Position+Len+SectorSize-1)/SectorSize;
NumSectors = EndSector - StartSector;
if((NumSectors*SectorSize) > MAX_DATA_LEN)
{
uprintf("Please increase MAX_DATA_LEN in file.h\n");
return 0;
}
if(Len > 0xFFFFFFFFUL)
{
uprintf("write_data: Len is too big\n");
return 0;
}
/* Data to write may not be aligned on a sector boundary => read into a sector buffer first */
if(read_sectors(hDrive, SectorSize, StartSector,
NumSectors, aucBuf) <= 0)
return 0;
if(!memcpy(&aucBuf[Position - StartSector*SectorSize], pData, (size_t)Len))
return 0;
if(write_sectors(hDrive, SectorSize, StartSector,
NumSectors, aucBuf) <= 0)
return 0;
return 1;
} /* write_data */
/* update an FAT in file system according to FAT buffer */
int updateFat(int which) {
/* since we store the FAT by entries, every entry is 4 Bytes */
return write_sectors(fat_addr + which*be.BPB_FATSz32,
(unsigned char *)FAT, be.BPB_FATSz32);
}
int main( int argc, char *argv[]){
if(argc < 3) {
printf("Usage: %s filename.img] Size x.x MB\n", argv[0]);
return 1;
}
int i, j;
unsigned long last_cnt;
strcpy(drv_type,"hd");
strcpy(filename,argv[1]);
cylinders = (atof(argv[2])*2.1)/1024/1024;// << 1);
printf("creating FAT12 image size = %3.2f MB's\n",cylinders/2);
// print start string
//printf(strtstr);
//do {
// printf("Make Floppy or Hard Drive image? (fd/hd) [fd]: ");
// gets(drv_type);
// if (!strlen(drv_type)) { strcpy(drv_type, "fd"); break; }
//} while (strcmp(drv_type, "fd") && strcmp(drv_type, "hd"));
//printf(" As filename [%c.img]: ", (drv_type[0] == 'h') ? 'c' : 'a');
//gets(filename);
//if (!strlen(filename)) strcpy(filename, (drv_type[0] == 'h') ? "c.img" : "a.img");
//if (drv_type[0] == 'h') {
// do {
// printf(" Size (meg) (1 - 1024) [10]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 10;
// else
// i = atoi(strbuff);
// } while ((i < 1) || (i > 1024));
//cylinders = (10 << 1); // very close at 16 heads and 63 spt
heads = 16;
spt = 63;
fat_size = 12;
//} else {
// do {
// printf(" Sectors per track (8, 9, 15, 18, 36) [18]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 18;
// else
// i = atoi(strbuff);
// } while ((i != 8) && (i != 9) && (i != 15) && (i != 18) && (i != 36));
// if (i == 36) spclust = 2;
// spt = i;
// do {
// printf(" Heads: (1, 2) [2]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 2;
// else
// i = atoi(strbuff);
// } while ((i != 1) && (i != 2));
// heads = i;
// do {
// printf(" Cylinders: (40, 80) [80]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 80;
// else
// i = atoi(strbuff);
// } while ((i != 40) && (i != 80));
// cylinders = i;
// fat_size = 12;
//}
sectors = (cylinders * heads * spt);
//do {
// printf(" Sectors per Cluster [% 2i]: ", spclust);
// gets(strbuff);
// if (!strlen(strbuff))
// i = spclust;
// else
// i = atoi(strbuff);
//} while (i > 255);
//spclust = i;
//do {
// printf(" Number of FAT's [2]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// fats = 2;
// else
// fats = atoi(strbuff);
//} while (fats > 2);
//
//do {
// printf(" FAT Size: [%02i]: ", fat_size);
// gets(strbuff);
// if (!strlen(strbuff))
// i = fat_size;
// else
// i = atoi(strbuff);
//} while ((i != 12) && (i != 16) && (i != 32));
//fat_size = i;
switch (fat_size) {
case 12:
//if ((sectors / (unsigned long) spclust) > 4086L) {
// printf(" *** Illegal Size disk with FAT 12 *** \n");
// exit(0x12);
//}
spfat = (unsigned short) ((unsigned short)((float) sectors * 1.5) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) ((float) last_cnt * 1.5) % 512);
break;
case 16:
if ((sectors / (unsigned long) spclust) > 65526L) {
printf(" *** Illegal Size disk with FAT 16 *** \n");
exit(0x12);
}
spfat = (unsigned short) ((sectors << 1) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) (last_cnt << 1) % 512);
break;
default:
spfat = (unsigned short) ((sectors << 2) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) (last_cnt << 2) % 512);
}
//printf("\n Creating file: [%s]"
// "\n Cylinders: %i"
// "\n Sides: %i"
// "\n Sectors/Track: %i"
// "\n Total Sectors: %lu"
// "\n Size: %3.2f (megs)"
// "\n Sectors/Cluster: %i"
// "\n FAT's: %i"
// "\n Sectors/FAT: %i"
// "\n FAT size: %i",
// filename, cylinders, heads, spt, sectors,
// (float) ((float) sectors / 2000.0), spclust, fats, spfat, fat_size);
// create BPB
bpb.jmps[0] = 0xEB; bpb.jmps[1] = 0x3C;
bpb.nop = 0x90;
memcpy(bpb.oemname, "MKDOSFS ", 8); // char oemname[8]; // OEM name
bpb.nBytesPerSec = 512; // unsigned short nBytesPerSec; // Bytes per sector
bpb.nSecPerClust = spclust; // unsigned char nSecPerClust; // Sectors per cluster
bpb.nSecRes = 1; // unsigned short nSecRes; // Sectors reserved for Boot Record
bpb.nFATs = fats; // unsigned char nFATs; // Number of FATs
bpb.nRootEnts = 224; // unsigned short nRootEnts; // Max Root Directory Entries allowed
if (sectors < 65536) { // unsigned short nSecs; // Number of Logical Sectors
bpb.nSecs = (unsigned short) sectors;
bpb.nSecsExt = 0; // unsigned long nSecsExt; // This value used when there are more
} else {
bpb.nSecs = 0;
bpb.nSecsExt = sectors; // unsigned long nSecsExt; // This value used when there are more
}
bpb.mDesc = 0xF9; // unsigned char mDesc; // Medium Descriptor Byte (we have it set as floppy 1.44)
bpb.nSecPerFat = spfat; // unsigned short nSecPerFat; // Sectors per FAT
bpb.nSecPerTrack = spt; // unsigned short nSecPerTrack; // Sectors per Track
bpb.nHeads = heads; // unsigned short nHeads; // Number of Heads
bpb.nSecHidden = 0; // unsigned long nSecHidden; // Number of Hidden Sectors
bpb.DriveNum = 0; // unsigned char DriveNum; // Physical drive number
bpb.nResByte = 0; // unsigned char nResByte; // Reserved (we use for FAT type (12- 16-bit)
bpb.sig = 0x29; // unsigned char sig; // Signature for Extended Boot Record
bpb.SerNum = 0; // unsigned long SerNum; // Volume Serial Number
memcpy(bpb.VolName, "NO LABEL ", 11); // char VolName[11]; // Volume Label
sprintf(strbuff, "FAT%2i ", fat_size);
memcpy(bpb.FSType, strbuff, 8); // char FSType[8]; // File system type
memset(bpb.filler, 0, 448); // first, clear it out
memcpy(bpb.filler, boot_code, sizeof(boot_code)); // then place code
memcpy(bpb.filler+sizeof(boot_code), boot_data, sizeof(boot_data)); // then place data
bpb.boot_sig = 0xAA55;
if ((fp = fopen(filename, "wb")) == NULL) {
printf("\nError creating file [%s]", filename);
return 0x01;
}
printf("\n\nWorking[");
// write the BPB
putdot();
write_sectors(fp, &bpb, 1);
sectors--;
// write the FAT(s)
for (i=0; i<fats; i++) {
memset(buffer, 0, 512);
switch (fat_size) {
case 32:
buffer[7] = 0xFF;
buffer[6] = 0xFF;
buffer[5] = 0xFF;
buffer[4] = 0xFF;
case 16:
buffer[3] = 0xFF;
case 12:
buffer[0] = 0xF9;
buffer[1] = 0xFF;
buffer[2] = 0xFF;
}
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
memset(buffer, 0, 512);
for (j=0; j<spfat-2; j++) {
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write last sector of FAT filling in unused entries
// (last_cnt isn't exact, but it is pretty close. I just
// didn't want to spend the time to get it exact :)
memset(buffer, 0, (unsigned short) last_cnt);
memset(buffer + last_cnt, 0xFF, (unsigned short) (512-last_cnt));
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write the root
memset(buffer, 0, 512);
for (i=0; i<14; i++) {
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write data area
memset(buffer, 0, 512);
while (sectors--) {
putdot();
write_sectors(fp, &buffer, 1);
}
printf("]Done");
// close the file
fclose(fp);
return 0x00;
}
