/* 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; }