static int devfd_transfer(bool is_read, uint8_t is_raw)
{
int ct = 0;
int tries;
int blocks = udata.u_nblock;
uint16_t lba = udata.u_block;
// kprintf("[%s %d @ %x : %d:%x]\n", is_read ? "read" : "write",
// blocks, lba, is_raw, udata.u_dptr);
// if (!is_read)
// return blocks << BLKSHIFT;
if (is_raw && d_blkoff(BLKSHIFT))
return -1;
fd_select(0);
fd765_is_user = is_raw;
fd765_buffer = udata.u_dptr;
while (blocks != 0)
{
for (tries = 0; tries < 3; tries ++)
{
nudge_timer();
if (tries != 0)
fd_recalibrate();
fd_seek(lba);
fd765_sectors = 10 - fd765_sector;
if (fd765_sectors > blocks)
fd765_sectors = blocks;
if (is_read)
fd765_do_read();
else
fd765_do_write();
/* Did it work ? */
if ((fd765_status[0] & 0xc0) == 0)
break;
}
if (tries == 3)
{
kprintf("fd%d: I/O error %d:%d\n", is_read, lba);
udata.u_error = EIO;
break;
}
lba += fd765_sectors;
blocks -= fd765_sectors;
ct += fd765_sectors;
}
return ct << BLKSHIFT;
}
static void fd_calibrate_done(int status)
{
DPRINT(("fd_calibrate_done()\n"));
STOP_TIMEOUT();
/* set the correct speed now */
if (status & FDC1772STAT_RECNF) {
printk("fd%d: restore failed\n", SelectedDrive);
fd_error();
} else {
unit[SelectedDrive].track = 0;
fd_seek();
}
}
uint klseek(FILE file, uint offset, uint direction){
struct stat status;
uint err = fd_stat(file, &status);
if(err != 0)
return (uint) -1;
switch(direction){
case SEEK_SET:
fd_seek(file, offset);
break;
case SEEK_CUR:
fd_seek(file, fd_offset(file) + offset);
break;
case SEEK_END:
fd_seek(file, status.st_size + offset);
break;
default:
return (uint) -1;
}
return 0;
}
static void do_fd_action(int drive)
{
struct request *req;
DPRINT(("do_fd_action unit[drive].track=%d\n", unit[drive].track));
#ifdef TRACKBUFFER
repeat:
if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
req = CURRENT;
if (ReqCmd == READ) {
copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
if (++ReqCnt < req->current_nr_sectors) {
/* read next sector */
setup_req_params( drive );
goto repeat;
} else {
/* all sectors finished */
req->nr_sectors -= req->current_nr_sectors;
req->sector += req->current_nr_sectors;
end_request(req, 1);
redo_fd_request();
return;
}
} else {
/* cmd == WRITE, pay attention to track buffer
* consistency! */
copy_buffer( ReqData, SECTOR_BUFFER(ReqSector) );
}
}
#endif
if (SelectedDrive != drive) {
/*unit[drive].track = -1; DAG */
fd_select_drive(drive);
};
if (unit[drive].track == -1)
fd_calibrate();
else if (unit[drive].track != ReqTrack << unit[drive].disktype->stretch)
fd_seek();
else
fd_rwsec();
}
static void describe_monster_desc(const monster_race *r_ptr)
{
char buf[2048];
char *s, *t;
int match = (r_ptr->flags1 & (RF1_FEMALE)) ? 2 : 1;
int state = 0;
#ifdef DELAY_LOAD_R_TEXT
int fd;
/* Build the filename */
path_build(buf, 1024, ANGBAND_DIR_DATA, "monster.raw");
/* Open the "raw" file */
fd = fd_open(buf, O_RDONLY);
/* Use file */
if (fd >= 0)
{
long pos;
/* Starting position */
pos = r_ptr->text;
/* Additional offsets */
pos += r_head->head_size;
pos += r_head->info_size;
pos += r_head->name_size;
#if 0
/* Maximal length */
len = r_head->text_size - r_ptr->text;
/* Actual length */
for (i = r_idx+1; i < z_info->r_max; i++)
{
/* Actual length */
if (r_info[i].text > r_ptr->text)
{
/* Extract length */
len = r_info[i].text - r_ptr->text;
/* Done */
break;
}
}
/* Maximal length */
if (len > 2048) len = 2048;
#endif
/* Seek */
fd_seek(fd, pos);
/* Read a chunk of data */
fd_read(fd, buf, sizeof(buf));
/* Close it */
fd_close(fd);
}
#else
/* Simple method */
my_strcpy(buf, r_text + r_ptr->text, sizeof(buf));
#endif
/* Remove gender sensitivity */
for (t = s = buf; *s; s++)
{
if (*s == '|')
{
state++;
if (state == 3) state = 0;
}
else if (!state || (state == match))
{
*t++ = *s;
}
}
/* Terminate buffer */
*t = '\0';
/* Dump it */
text_out(buf);
if (strlen(buf)) text_out(" ");
}
/*
* Seek score 'i' in the highscore file
*/
static int highscore_seek(int i)
{
/* Seek for the requested record */
return (fd_seek(highscore_fd, (huge)(i) * sizeof(high_score)));
}
static void describe_monster_desc(int r_idx)
{
const monster_race *r_ptr = &r_info[r_idx];
char buf[2048];
#ifdef DELAY_LOAD_R_TEXT
int fd;
/* Build the filename */
path_build(buf, 1024, ANGBAND_DIR_DATA, "monster.raw");
/* Open the "raw" file */
fd = fd_open(buf, O_RDONLY);
/* Use file */
if (fd >= 0)
{
long pos;
/* Starting position */
pos = r_ptr->text;
/* Additional offsets */
pos += r_head->head_size;
pos += r_head->info_size;
pos += r_head->name_size;
#if 0
/* Maximal length */
len = r_head->text_size - r_ptr->text;
/* Actual length */
for (i = r_idx+1; i < z_info->r_max; i++)
{
/* Actual length */
if (r_info[i].text > r_ptr->text)
{
/* Extract length */
len = r_info[i].text - r_ptr->text;
/* Done */
break;
}
}
/* Maximal length */
if (len > 2048) len = 2048;
#endif
/* Seek */
fd_seek(fd, pos);
/* Read a chunk of data */
fd_read(fd, buf, sizeof(buf));
/* Close it */
fd_close(fd);
}
#else
/* Simple method */
strcpy(buf, r_text + r_ptr->text);
#endif
/* Dump it */
text_out(buf);
if (strlen(buf)) text_out(" ");
}
static int fd_transfer(uint8_t minor, bool is_read, uint8_t rawflag)
{
int8_t tries;
uint8_t err = 0;
uint8_t drive = minor & 3;
uint8_t trackno, sector;
uint8_t large = !(minor & 0x10);
const uint8_t *skew = skewtab[large]; /* skew table */
if(rawflag == 2)
goto bad2;
fd_map = rawflag;
if (rawflag && d_blkoff(BLKSHIFT))
return -1;
/* Command to go to the controller after any seek is done */
fd_cmd[0] = is_read ? FD_READ : FD_WRITE;
/* Control byte: autowait, DD, motor, 5", drive bit */
fd_cmd[1] = 0xE0 | selmap[drive];
if (large)
fd_cmd[1] = 0x10; /* turn on 8" bit */
/* Directon of xfer */
fd_cmd[2] = is_read ? OPDIR_READ: OPDIR_WRITE;
fd_cmd[5] = 0x10 | delay[drive];
/*
* Restore the track register to match this drive
*/
if (track[drive] != 0xFF)
fd_track = track[drive];
else
fd_reset();
/*
* Begin transfers
*/
while (udata.u_done < udata.u_nblock) {
/* Need to consider SS v DS here */
if (large) {
fd_aux = 0x4C | (udata.u_block & 16) ? 2 : 0;
trackno = udata.u_block / 32;
sector = udata.u_block % 16;
} else {
trackno = udata.u_block / 20;
sector = udata.u_block % 20;
if (sector > 9) {
sector -= 10;
fd_aux = 0x5E; /* side 1 */
} else
fd_aux = 0x5C;
}
/* Buffer */
fd_cmd[3] = ((uint16_t)udata.u_dptr) & 0xFF;
fd_cmd[4] = ((uint16_t)udata.u_dptr) >> 8;
for (tries = 0; tries < 4 ; tries++) {
(void)fd_data;
fd_sector = skew[sector]; /* Also makes 1 based */
if (fd_track != trackno) {
fd_data = trackno;
if (fd_seek()) {
fd_reset();
continue;
}
}
/* Do the read or write */
err = fd_operation();
if (err == 0)
break;
/* Try and recover */
if (tries > 1)
fd_reset();
}
if (tries == 4)
goto bad;
udata.u_block++;
udata.u_done++;
}
/* Save the track */
track[drive] = fd_track;
return udata.u_done << 9;
bad:
track[drive] = fd_track;
kprintf("fd%d: error %x\n", minor, err);
bad2:
udata.u_error = EIO;
return -1;
}
