VOID spol_gblk(VOID)
{
BYTE handle;
#if GEMDOS
handle = Fopen( (const char *)spol_path, 0x0000 );
#else
handle = dos_open( spol_path, 0x0000 );
#endif
if (handle)
{
#if GEMDOS
Fseek( spol_fcnt, handle, 0x0000 );
spol_cntr = (WORD)Fread( handle, SPLSIZE, (VOID *)spol_pbuf );
#else
dos_lseek( handle, 0x0000, spol_fcnt );
spol_cntr = dos_read( handle, SPLSIZE, spol_pbuf );
#endif
if ( spol_cntr != SPLSIZE )
spol_sts = TRUE;
spol_fcnt += LW( spol_cntr );
#if GEMDOS
Fclose( handle );
#else
dos_close( handle );
#endif
spol_ptr = spol_bufr;
}
else
{
spol_sts = TRUE;
spol_cntr = 0;
}
}
/*
* Routine to read in the start of the emudesk.inf file,
* expected to contain the #E and #Z lines.
*/
static void sh_rdinf(void)
{
WORD fh;
LONG size, ret;
char *pfile;
char tmpstr[MAX_LEN];
infbuf[0] = 0;
strcpy(tmpstr, INF_FILE_NAME);
pfile = tmpstr;
*pfile += dos_gdrv(); /* set the drive */
ret = dos_open(pfile, ROPEN);
if (ret < 0L)
return;
fh = (WORD)ret;
/* NOTA BENE: all required info MUST be within INF_SIZE
* bytes from the beginning of the file
*/
size = dos_read(fh, INF_SIZE, infbuf);
dos_close(fh);
if (size < 0L) /* if read error, force empty buffer */
size = 0L;
infbuf[size] = 0;
}
int cmd_type(char *param)
{
char buf[256];
char **argv;
int argc, opts, ec = E_None;
int fd, len;
if((argv = scanCmdline(param, 0, 0, &argc, &opts)) == 0)
return 1;
/* Because no option was passed into scanCmdline() no
option can have been processed */
assert(opts == 0);
if(!argc) {
error_req_param_missing();
ec = E_Useage;
goto errRet;
}
for(argc = 0; argv[argc]; ++argc) {
if((fd = devopen(argv[argc], O_RDONLY)) == 0) {
error_sfile_not_found(argv[argc]);
ec = E_Other;
break;
}
while((len = dos_read(fd, buf, sizeof(buf))) >= 0) {
char *bufp, *p;
if(cbreak) {
dos_close(fd);
ec = E_CBreak;
goto errRet;
}
bufp = buf;
for(p = buf; p < buf+len; p++) {
if(*p == 26) break; /* CTRL-Z */
if(*p == '\r' || *p == '\n') {
if(p > bufp) dos_write(1, bufp, p - bufp);
if(*p == '\n') dos_write(1, "\r\n", 2);
bufp = p + 1;
}
}
dos_write(1, bufp, p - bufp);
if (len < sizeof(buf) || *p == 26) break;
}
dos_close(fd);
if(cbreak) {
ec = E_CBreak;
break;
}
}
errRet:
freep(argv);
return ec;
}
int enumFileResources(const char *const fnam
, res_majorid_t id
, res_callbackp_t fct
, void * const arg)
{ resource_t res;
unsigned long pos;
int rc;
int fd;
assert(fct);
if(!fnam)
return -1;
rc = 0;
#ifdef PTCHSIZE
if((fd = open(fnam, O_RDONLY | O_BINARY)) < 0) {
#else
if((fd = dos_open(fnam, O_RDONLY)) < 0) {
#endif
rc = -1;
dprintf(("[RES: Failed to open file: %s]\n", fnam));
#ifdef DEBUG
perror("Open");
#endif
/* resource file could be opened
The first resource item is located at the end of the file,
the var #("pos#(" is used to indicate the absolute position
within the file as relative positioning is failing under
NTFSdos {Tom Ehlert} */
} else if((pos = filelength(fd)) != (unsigned long)-1L)
while (1) {
if(pos <= sizeof(res) /* file corruption */
/* read and verify the resource ID block */
|| lseek(fd, pos -= sizeof(res), SEEK_SET) < 0 /* seek error */
|| dos_read(fd, &res, sizeof(res)) != sizeof(res) /* read error */
/* file corruption as magic string is missing */
|| memcmp(res.res_cookie, RES_COOKIE, sizeof(res.res_cookie)) != 0
/* file corruption: not that many bytes left in file */
|| pos < res.res_length
/* failed to position to data block in the file */
|| lseek(fd, pos -= res.res_length, SEEK_SET) < 0
)
break;
if (res.res_majorID == id || id == RES_ID_ANY)
if ((rc = fct(res.res_majorID
, res.res_minorID
, res.res_length
, fd
, arg)) != 0)
break;
}
dos_close(fd);
return rc;
}
static msg_t *
input_pipe_reader (LHANDLE handle, qid_t qid, msg_t * message, int * eofp)
{
ULONG nread;
APIRET rc
= (dos_read (handle,
(SM_READAHEAD_DATA (message)),
(sizeof (SM_READAHEAD_DATA (message))),
(& nread)));
if (rc == NO_ERROR)
{
(SM_READAHEAD_SIZE (message)) = nread;
(*eofp) = (nread == 0);
return (message);
}
OS2_destroy_message (message);
if (rc == ERROR_INVALID_HANDLE)
/* Handle was closed on us -- no need to do anything else. */
return (0);
(*eofp) = (rc == ERROR_BROKEN_PIPE);
return (OS2_make_syscall_error (rc, syscall_dos_read));
}
/*
* Routine to read in the start of the emudesk.inf file,
* expected to contain the #E and #Z lines.
*/
static void sh_rdinf(void)
{
WORD fh, size;
char *pfile;
char tmpstr[MAX_LEN];
infbuf[0] = 0;
strcpy(tmpstr, INF_FILE_NAME);
pfile = tmpstr;
*pfile += dos_gdrv(); /* set the drive */
fh = dos_open(pfile, ROPEN);
if ( !fh || DOS_ERR)
return;
/* NOTA BENE all required info */
/* MUST be within INF_SIZE */
/* bytes from beg of file */
size = dos_read(fh, INF_SIZE, (LONG)infbuf);
dos_close(fh);
if (DOS_ERR)
return;
infbuf[size] = 0;
}
void cdrom_helper(unsigned char *req_buf, unsigned char *transfer_buf,
unsigned int dos_transfer_buf)
{
unsigned int Sector_plus_150,Sector;
struct cdrom_msf cdrom_msf;
struct cdrom_subchnl cdrom_subchnl;
struct cdrom_tochdr cdrom_tochdr;
struct cdrom_tocentry cdrom_tocentry;
struct cdrom_volctrl cdrom_volctrl;
int n, err;
cdrom_subchnl.cdsc_format = CDROM_MSF;
IndexCd=(int)((HI(ax) & 0xC0)>>6);
HI(ax) = HI(ax) & 0x3F;
if ((cdu33a) && (cdrom_fd < 0)) {
cdrom_fd = open (path_cdrom, O_RDONLY | O_NONBLOCK);
if (cdrom_fd < 0) {
switch (HI(ax)) {
case 0x09: /* media changed request */
LO(bx) = 1; /* media changed */
LO(ax) = 0;
return;
case 0x0A: /* device status request */
LWORD(ebx) = audio_status.status | 0x800; /* no disc */
LO(ax) = 0;
return;
}
LO(ax) = 1; /* for other requests return with error */
return ;
}
}
switch (HI(ax)) {
case 0x01: /* NOTE: you can't see XA data disks if bit 10 of status
* is cleared, MSCDEX will test it and skip XA entries!
* Actually the entries skipped must have this pattern:
* xxxx1xxx xxxxxxxx 0x58 0x41
* and the mscdex 2.25 code is:
* test word ptr [bx+1Eh],400h
* jz [check for XA]
* [return 0 = valid entry]
* [check for XA]
* ...
* cmp word ptr es:[bx+6],4158h 'XA'
* jne [return 0]
* mov ax,es:[bx+4]
* and ax,8
* [return ax]
*/
audio_status.status = 0x00000710; /* see function 0x0A below */
audio_status.paused_bit = 0;
audio_status.media_changed = 0;
audio_status.volume0 = 0xFF;
audio_status.volume1 = 0xFF;
audio_status.volume2 = 0;
audio_status.volume3 = 0;
audio_status.outchan0 = 0;
audio_status.outchan1 = 1;
audio_status.outchan2 = 2;
audio_status.outchan3 = 3;
cdrom_fd = open (path_cdrom, O_RDONLY | O_NONBLOCK);
err = errno;
if (cdrom_fd < 0) {
C_printf("CDROM: cdrom open (%s) failed: %s\n",
path_cdrom, strerror(err));
LO(ax) = 0;
if ((err == EIO) || (err==ENOMEDIUM)) {
/* drive which cannot be opened if no
disc is inserted! */
cdu33a = 1;
if (! eject_allowed)
LO(ax) = 1; /* no disk in drive */
}
else LO(ax) = 1; /* no cdrom drive installed */
if (! eject_allowed)
LO(ax) = 1; /* no disk in drive */
}
else {
LO(ax) = 0;
if (! eject_allowed) {
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr))
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr))
LO(ax) = 1;
}
}
break;
case 0x02: /* read long */
if (eject_allowed && ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl) && errno != ENOTTY) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disc in drive */
LO(ax) = 1;
break;
}
else { /* disc in drive */
}
}
if (req_buf == NULL && transfer_buf == NULL) {
req_buf = SEG_ADR((unsigned char *), es, di);
dos_transfer_buf = SEGOFF2LINEAR(REG(ds), LWORD(esi));
}
if (*CALC_PTR(req_buf,MSCD_READ_ADRESSING,u_char) == 1) {
cdrom_msf.cdmsf_min0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+2,u_char);
cdrom_msf.cdmsf_sec0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+1,u_char);
cdrom_msf.cdmsf_frame0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+0,u_char);
Sector = cdrom_msf.cdmsf_min0*60*75+cdrom_msf.cdmsf_sec0*75
+cdrom_msf.cdmsf_frame0-150;
}
else { Sector = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR,u_long);
}
C_printf("CDROM: reading sector %#x (fmt %d)\n", Sector,
*CALC_PTR(req_buf,MSCD_READ_ADRESSING,u_char));
if ((off_t) -1 == lseek (cdrom_fd, Sector*CD_FRAMESIZE, SEEK_SET)) {
HI(ax) = (errno == EINVAL ? 0x08 : 0x0F);
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
} else {
n = *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE;
if (transfer_buf == NULL) {
n = dos_read (cdrom_fd, dos_transfer_buf, n);
} else {
n = unix_read (cdrom_fd, transfer_buf, n);
}
if ( n < 0 ) {
/* cd must be in drive, reset drive and try again */
cdrom_reset();
if ((off_t) -1 == lseek (cdrom_fd, Sector*CD_FRAMESIZE, SEEK_SET)) {
HI(ax) = (errno == EINVAL ? 0x08 : 0x0F);
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
} else {
n = *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE;
if (transfer_buf == NULL)
n = dos_read (cdrom_fd, dos_transfer_buf, n);
else
n = unix_read (cdrom_fd, transfer_buf, n);
if ( n < 0) {
HI(ax) = (errno == EFAULT ? 0x0A : 0x0F);
C_printf("CDROM: sector read (to %p, len %#x) failed: %s\n",
transfer_buf, *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE, strerror(errno));
LO(ax) = 1;
} else LO(ax) = 0;
}
}
if (n != *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE) {
C_printf("CDROM: sector read len %#x got %#x\n",
*CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE, n);
LO(ax) = 1;
HI(ax) = 0x0F;
} else {
#ifdef CDROM_DEBUG
dump_cd_sect(transfer_buf);
#endif
LO(ax) = 0;
}
}
break;
case 0x03: /* seek */
req_buf = SEG_ADR((unsigned char *), es, di);
if ((off_t)-1 == lseek (cdrom_fd, *CALC_PTR(req_buf,MSCD_SEEK_STARTSECTOR,u_long)*CD_FRAMESIZE, SEEK_SET)) {
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
}
break;
case 0x04: /* play */
req_buf = SEG_ADR((unsigned char *), es, di);
if (*CALC_PTR(req_buf,MSCD_PLAY_ADRESSING,u_char) == 1) {
cdrom_msf.cdmsf_min0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+2,u_char);
cdrom_msf.cdmsf_sec0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+1,u_char);
cdrom_msf.cdmsf_frame0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+0,u_char);
Sector_plus_150 = cdrom_msf.cdmsf_min0*60*75+cdrom_msf.cdmsf_sec0*75
+cdrom_msf.cdmsf_frame0;
audio_status.last_StartSector = Sector_plus_150;
}
else { Sector_plus_150 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR,u_long) + 150;
cdrom_msf.cdmsf_min0 = (Sector_plus_150 / (60*75));
cdrom_msf.cdmsf_sec0 = (Sector_plus_150 % (60*75)) / 75;
cdrom_msf.cdmsf_frame0 = (Sector_plus_150 % (60*75)) % 75;
audio_status.last_StartSector = Sector_plus_150;
}
Sector_plus_150 += *CALC_PTR(req_buf,MSCD_PLAY_NUMSECTORS,u_long);
cdrom_msf.cdmsf_min1 = (Sector_plus_150 / (60*75));
cdrom_msf.cdmsf_sec1 = (Sector_plus_150 % (60*75)) / 75;
cdrom_msf.cdmsf_frame1 = (Sector_plus_150 % (60*75)) % 75;
audio_status.last_EndSector = Sector_plus_150;
audio_status.paused_bit = 0;
if (ioctl (cdrom_fd, CDROMPLAYMSF, &cdrom_msf)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMPLAYMSF, &cdrom_msf)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
LO(ax) = 0;
break;
case 0x05: /* pause (stop) audio */
LO(ax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl) == 0) {
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY) {
audio_status.last_StartSector =
cdrom_subchnl.cdsc_absaddr.msf.minute*60*75
+cdrom_subchnl.cdsc_absaddr.msf.second*75
+cdrom_subchnl.cdsc_absaddr.msf.frame;
ioctl (cdrom_fd, CDROMPAUSE, NULL);
audio_status.paused_bit = 1;
}
else { audio_status.last_StartSector = 0;
audio_status.last_EndSector = 0;
audio_status.paused_bit = 0;
}
}
else { audio_status.last_StartSector = 0;
audio_status.last_EndSector = 0;
audio_status.paused_bit = 0;
audio_status.media_changed = 1;
}
break;
case 0x06: /* resume audio */
LO(ax) = 0;
if (audio_status.paused_bit) {
if (ioctl (cdrom_fd, CDROMRESUME, NULL) == 0) {
audio_status.paused_bit = 0;
HI(ax) = 1;
}
}
else LO(ax) = 1;
break;
case 0x07: /* location of head */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
if (*CALC_PTR(req_buf,MSCD_LOCH_ADRESSING,u_char) == 0) {
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION,u_long)
= cdrom_subchnl.cdsc_absaddr.msf.minute*60*75
+cdrom_subchnl.cdsc_absaddr.msf.second*75
+cdrom_subchnl.cdsc_absaddr.msf.frame-150;
}
else {/* red book adressing */
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+2,u_char) = cdrom_subchnl.cdsc_absaddr.msf.minute;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+1,u_char) = cdrom_subchnl.cdsc_absaddr.msf.second;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+0,u_char) = cdrom_subchnl.cdsc_absaddr.msf.frame;
}
break;
case 0x08: /* return sectorsize */
LO(ax) = 0;
LWORD(ebx) = CD_FRAMESIZE;
break;
case 0x09: /* media changed */
/* this function will be called from MSCDEX before
each new disk access ! */
HI(ax) = 0; LO(ax) = 0; LO(bx) = 0;
C_printf("CDROM: media changed? %#x\n", audio_status.media_changed);
errno = 0;
if (eject_allowed) {
if ((audio_status.media_changed) ||
ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
if (errno == EIO)
cdrom_reset();
audio_status.media_changed = 0;
LO(bx) = 1; /* media has been changed */
C_printf("CDROM: media changed? yes\n");
ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl);
if (! ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl))
cdrom_reset(); /* disc in drive */
}
else /* media has not changed, check audio status */
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1; /* audio playing in progress */
}
break;
case 0x0A: /* device status */
HI(ax) = 0; LO(ax) = 0;
if (eject_allowed) {
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl))
{ /* no disk in drive */
LWORD(ebx) = audio_status.status | 0x800;
C_printf("CDROM: subch failed: %s\n", strerror(errno));
break;
}
else cdrom_reset();
}
}
/* disk in drive */
LWORD(ebx) = audio_status.status;
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
break;
case 0x0B: /* drive reset */
LO(ax) = 0;
break;
case 0x0C: /* lock/unlock door */
cdrom_reset();
if (LO(bx) == 1)
audio_status.status &= 0xFFFFFFFD;
else audio_status.status |= 0x2;
LO(ax) = 0;
break;
case 0x0D: /* eject */
LO(ax) = 0;
if ((eject_allowed) && (audio_status.status & 0x02)) /* drive unlocked ? */
{
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMEJECT)) {
LO(ax) = errno;
}
}
break;
case 0x0E: /* close tray */
LO(ax) = 0;
if ((eject_allowed) && (audio_status.status & 0x02)) /* drive unlocked ? */
{
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMCLOSETRAY)) {
LO(ax) = errno;
}
}
break;
case 0x0F: /* audio channel control */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
cdrom_volctrl.channel0 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME0, u_char);
cdrom_volctrl.channel1 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME1, u_char);
cdrom_volctrl.channel2 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME2, u_char);
cdrom_volctrl.channel3 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME3, u_char);
audio_status.volume0 = cdrom_volctrl.channel0;
audio_status.volume1 = cdrom_volctrl.channel1;
audio_status.volume2 = cdrom_volctrl.channel2;
audio_status.volume3 = cdrom_volctrl.channel3;
audio_status.outchan0 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME0-1, u_char);
audio_status.outchan1 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME1-1, u_char);
audio_status.outchan2 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME2-1, u_char);
audio_status.outchan3 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME3-1, u_char);
ioctl (cdrom_fd, CDROMVOLCTRL, &cdrom_volctrl);
break;
case 0x10: /* audio disk info */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_DISKINFO_LTN,u_char) = cdrom_tochdr.cdth_trk0;
*CALC_PTR(req_buf,MSCD_DISKINFO_HTN,u_char) = cdrom_tochdr.cdth_trk1;
cdrom_tocentry.cdte_track = CDROM_LEADOUT;
cdrom_tocentry.cdte_format = CDROM_MSF;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
C_printf ("Fatal cdrom error(audio disk info); read toc header succeeded but following read entry didn't\n");
LO(ax) = 1;
break;
}
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+2,u_char) = cdrom_tocentry.cdte_addr.msf.minute;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+1,u_char) = cdrom_tocentry.cdte_addr.msf.second;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+0,u_char) = cdrom_tocentry.cdte_addr.msf.frame;
#endif
break;
case 0x11: /* track info */
req_buf = SEG_ADR((unsigned char *), ds, si);
cdrom_tocentry.cdte_track = *CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKNUM,u_char);
cdrom_tocentry.cdte_format = CDROM_MSF;
C_printf("CDROM: track info, track %d\n", cdrom_tocentry.cdte_track);
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
/* XXX MSCDEX reads beyond the end of existing tracks. Sigh. */
if (errno != EINVAL)
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
if (errno == EIO) {
audio_status.media_changed = 1;
/* no disk in drive */
}
LO(ax) = 1;
break;
}
}
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+2,u_char) = cdrom_tocentry.cdte_addr.msf.minute;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+1,u_char) = cdrom_tocentry.cdte_addr.msf.second;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+0,u_char) = cdrom_tocentry.cdte_addr.msf.frame;
#endif
*CALC_PTR(req_buf,MSCD_TRACKINFO_CTRL,u_char) = cdrom_tocentry.cdte_ctrl << 4 | 0x20;
LO(ax) = 0;
break;
case 0x12: /* volume size */
cdrom_tocentry.cdte_track = CDROM_LEADOUT;
cdrom_tocentry.cdte_format = CDROM_MSF;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
req_buf = SEG_ADR((unsigned char *), ds, si);
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_GETVOLUMESIZE_SIZE,int) = cdrom_tocentry.cdte_addr.msf.minute*60*75
+cdrom_tocentry.cdte_addr.msf.second*60
+cdrom_tocentry.cdte_addr.msf.frame;
#endif
LO(ax) = 0;
break;
case 0x13: /* q channel */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_QCHAN_CTRL,u_char) = (cdrom_subchnl.cdsc_adr << 4) + (cdrom_subchnl.cdsc_ctrl);
*CALC_PTR(req_buf,MSCD_QCHAN_TNO,u_char) = cdrom_subchnl.cdsc_trk;
*CALC_PTR(req_buf,MSCD_QCHAN_IND,u_char) = cdrom_subchnl.cdsc_ind;
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_QCHAN_MIN,u_char) = cdrom_subchnl.cdsc_reladdr.msf.minute;
*CALC_PTR(req_buf,MSCD_QCHAN_SEC,u_char) = cdrom_subchnl.cdsc_reladdr.msf.second;
*CALC_PTR(req_buf,MSCD_QCHAN_FRM,u_char) = cdrom_subchnl.cdsc_reladdr.msf.frame;
#endif
*CALC_PTR(req_buf,MSCD_QCHAN_ZERO,u_char) = 0;
*CALC_PTR(req_buf,MSCD_QCHAN_AMIN,u_char) = cdrom_subchnl.cdsc_absaddr.msf.minute;
*CALC_PTR(req_buf,MSCD_QCHAN_ASEC,u_char) = cdrom_subchnl.cdsc_absaddr.msf.second;
*CALC_PTR(req_buf,MSCD_QCHAN_AFRM,u_char) = cdrom_subchnl.cdsc_absaddr.msf.frame;
break;
case 0x14: /* audio status */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_AUDSTAT_PAUSED,u_short)= audio_status.paused_bit;
*CALC_PTR(req_buf,MSCD_AUDSTAT_START ,u_long) = audio_status.last_StartSector;
*CALC_PTR(req_buf,MSCD_AUDSTAT_END ,u_long) = audio_status.last_EndSector;
break;
case 0x15: /* get audio channel information */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME0,u_char) = audio_status.volume0;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME1,u_char) = audio_status.volume1;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME2,u_char) = audio_status.volume2;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME3,u_char) = audio_status.volume3;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME0-1,u_char) = audio_status.outchan0;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME1-1,u_char) = audio_status.outchan1;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME2-1,u_char) = audio_status.outchan2;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME3-1,u_char) = audio_status.outchan3;
break;
default: C_printf ("CDROM: unknown request %#x!\n",HI(ax));
}
/*-----------------------------------------------------------------------------
* do_fdosboot --
*-----------------------------------------------------------------------------
*/
int do_fdosboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *name;
char *ep;
int size;
int rcode = 0;
char buf [12];
int drive = CONFIG_SYS_FDC_DRIVE_NUMBER;
/* pre-set load_addr */
if ((ep = getenv("loadaddr")) != NULL) {
load_addr = simple_strtoul(ep, NULL, 16);
}
/* pre-set Boot file name */
if ((name = getenv("bootfile")) == NULL) {
name = "uImage";
}
switch (argc) {
case 1:
break;
case 2:
/* only one arg - accept two forms:
* just load address, or just boot file name.
* The latter form must be written "filename" here.
*/
if (argv[1][0] == '"') { /* just boot filename */
name = argv [1];
} else { /* load address */
load_addr = simple_strtoul(argv[1], NULL, 16);
}
break;
case 3:
load_addr = simple_strtoul(argv[1], NULL, 16);
name = argv [2];
break;
default:
return cmd_usage(cmdtp);
}
/* Init physical layer */
if (!fdc_fdos_init (drive)) {
return (-1);
}
/* Open file */
if (dos_open (name) < 0) {
printf ("Unable to open %s\n", name);
return 1;
}
if ((size = dos_read (load_addr)) < 0) {
printf ("boot error\n");
return 1;
}
flush_cache (load_addr, size);
#ifdef CONFIG_AML_SECU_BOOT_V2
extern int g_nIMGReadFlag;
g_nIMGReadFlag = 0;
#endif //#ifdef CONFIG_AML_SECU_BOOT_V2
sprintf(buf, "%x", size);
setenv("filesize", buf);
printf("Floppy DOS load complete: %d bytes loaded to 0x%lx\n",
size, load_addr);
/* Check if we should attempt an auto-start */
if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
char *local_args[2];
local_args[0] = argv[0];
local_args[1] = NULL;
printf ("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
rcode = do_bootm (cmdtp, 0, 1, local_args);
}
return rcode;
}
int
more (int pfile, const char *descr, const char *prompt)
{
char ch; /* the character read from file */
int key; /* the key pressed by user */
int nchars = 0; /* no. of chars printed per line */
int nlines = 0; /* no. of lines printed per screen */
unsigned linecount = 0;
while (dos_read (pfile,&ch,1) > 0)
{
if (ch != '\t')
{
printf("%c",ch);
nchars++;
}
else
do { /* tab expansion */
printf(" ");
nchars++;
} while ( nchars < COLS && nchars % TABSIZE );
/* Determine if we have caused a new line to be printed.
Printing a CR/LF will do it, as will a screen wrap. */
if (ch == '\n')
linecount++;
if ((ch == '\n') || (nchars >= COLS))
{
nlines++;
nchars = 0;
if (nlines == (LINES-1))
{
/* We have met the printable screen boundary. Display
a prompt, and wait for a keypress before we show more. */
/* Since we don't necessarily know if the user is
redirecting to a file, always display on stderr. */
printf( "-- %s -- %s (%u)--", prompt, descr, linecount);
key = keypress();
printf("%40s\r","");
nlines = 0;
#if 0 /* debugging */
printf( "key=%d,%c\n", key, key);
#endif /* debugging */
/* Do we quit or move to next file? */
switch (key)
{
case CTRL_C:
printf( "^C");
case 'q':
case 'Q':
return (0);
case 'n':
case 'N':
return (1);
} /* switch */
} /* if NLINES */
} /* if COLS */
} /* while */
return 0;
}
BOOL FcbRead(xfcb FAR * lpXfcb, COUNT * nErrorCode)
{
sft FAR *s;
LONG lPosit;
COUNT nRead;
psp FAR *p = MK_FP(cu_psp, 0);
/* Convert to fcb if necessary */
lpFcb = ExtFcbToFcb(lpXfcb);
/* Get the SFT block that contains the SFT */
if ((s = FcbGetSft(lpFcb->fcb_sftno)) == (sft FAR *) - 1)
return FALSE;
/* If this is not opened another error */
if (s->sft_count == 0)
return FALSE;
/* Now update the fcb and compute where we need to position */
/* to. */
lPosit = ((lpFcb->fcb_cublock * 128) + lpFcb->fcb_curec)
* lpFcb->fcb_recsiz;
if (dos_lseek(s->sft_status, lPosit, 0) < 0)
{
*nErrorCode = FCB_ERR_EOF;
return FALSE;
}
if (s->sft_flags & SFT_FSHARED)
{
nRead = Remote_RW(REM_READ, lpFcb->fcb_recsiz, p->ps_dta, s, nErrorCode);
}
else
{
/* Do the read */
nRead = dos_read(s->sft_status, p->ps_dta, lpFcb->fcb_recsiz);
}
/* Now find out how we will return and do it. */
if (nRead == lpFcb->fcb_recsiz)
{
*nErrorCode = FCB_SUCCESS;
FcbNextRecord(lpFcb);
return TRUE;
}
else if (nRead < 0)
{
*nErrorCode = FCB_ERR_EOF;
return TRUE;
}
else if (nRead == 0)
{
*nErrorCode = FCB_ERR_NODATA;
return FALSE;
}
else
{
COUNT nIdx,
nCount;
BYTE FAR *lpDta;
nCount = lpFcb->fcb_recsiz - nRead;
lpDta = (BYTE FAR *) & (p->ps_dta[nRead]);
for (nIdx = 0; nIdx < nCount; nIdx++)
*lpDta++ = 0;
*nErrorCode = FCB_ERR_EOF;
FcbNextRecord(lpFcb);
return FALSE;
}
}
/*
* Initialize the application list by reading in the EMUDESK.INF
* file, either from memory or from the disk if the shel_get
* indicates no message is there.
*/
void app_start(void)
{
WORD i, x, y;
ANODE *pa;
WSAVE *pws;
BYTE *pcurr, *ptmp, *pauto = NULL;
WORD envr, xcnt, ycnt, xcent, wincnt, dummy;
/* remember start drive */
gl_stdrv = dos_gdrv();
G.g_pbuff = gl_buffer;
for (i = NUM_ANODES - 2; i >= 0; i--)
G.g_alist[i].a_next = &G.g_alist[i + 1];
G.g_ahead = (ANODE *) NULL;
G.g_aavail = G.g_alist;
G.g_alist[NUM_ANODES - 1].a_next = (ANODE *) NULL;
app_rdicon();
G.g_wicon = (12 * gl_wschar) + (2 * G.g_iblist[0].ib_xtext);
G.g_hicon = G.g_iblist[0].ib_hicon + gl_hschar + 2;
xcnt = G.g_wdesk / (G.g_wicon+MIN_WINT);/* icon count */
G.g_icw = G.g_wdesk / xcnt; /* width */
ycnt = G.g_hdesk / (G.g_hicon+MIN_HINT);/* icon count */
G.g_ich = G.g_hdesk / ycnt; /* height */
shel_get(gl_afile, SIZE_AFILE);
if (gl_afile[0] != '#') /* invalid signature */
{ /* so read from disk */
LONG ret;
WORD fh;
char inf_file_name[16];
strcpy(inf_file_name, INF_FILE_NAME);
inf_file_name[0] += gl_stdrv; /* Adjust drive letter */
ret = dos_open(inf_file_name, 0x0);
if (ret >= 0L)
{
fh = (WORD) ret;
ret = dos_read(fh, SIZE_AFILE, gl_afile);
G.g_afsize = (ret < 0L) ? 0L : ret;
dos_close(fh);
gl_afile[G.g_afsize] = '\0';
}
}
/* If there's still no desktop.inf data, use built-in now: */
if (gl_afile[0] != '#')
{
LONG drivemask;
char *text;
int icon_index = 0;
int drive_x = 0, drive_y = 0;
int trash_x, trash_y;
int icon_type;
char drive_letter;
/* Environment and Windows */
strcat(gl_afile, desk_inf_data1);
/* Scan for valid drives: */
drivemask = dos_sdrv(dos_gdrv());
for (i = 0; i < BLKDEVNUM; i++)
{
if (drivemask&(1L<<i))
{
x = strlen(gl_afile);
drive_x = icon_index % xcnt; /* x position */
drive_y = icon_index / xcnt; /* y position */
icon_type = (i > 1) ? 0 /* Hard disk */ : 1 /* Floppy */;
drive_letter = 'A' + i;
rsrc_gaddr(R_STRING, STDISK, (void **)&text);
sprintf(gl_afile + x, "#M %02X %02X %02X FF %c %s %c@ @\r\n",
drive_x, drive_y, icon_type, drive_letter, text, drive_letter);
icon_index++;
}
}
/* Copy core data part 2 */
strcat(gl_afile, desk_inf_data2);
/* add Trash icon to end */
x = strlen(gl_afile);
trash_x = 0; /* Left */
trash_y = ycnt-1; /* Bottom */
if (drive_y >= trash_y) /* if the last drive icon overflows over */
trash_x = xcnt-1; /* the trash row, force trash to right */
rsrc_gaddr(R_STRING, STTRASH, (void **)&text);
sprintf(gl_afile + x, "#T %02X %02X 03 FF %s@ @\r\n",
trash_x, trash_y, text);
G.g_afsize = strlen(gl_afile);
}
wincnt = 0;
inf_rev_level = 0;
pcurr = gl_afile;
while(*pcurr)
{
if (*pcurr++ != '#') /* look for start of line */
continue;
switch(*pcurr)
{
case 'R': /* revision level */
pcurr++;
pcurr = scan_2(pcurr,&inf_rev_level);
break;
case 'Z': /* autorun: Z nn pathname@ */
pcurr = scan_str(pcurr+5,&pauto); /* save pathname in buffer */
break; /* (a bit wasteful) */
case 'T': /* Trash */
case 'M': /* Media (Hard/Floppy) */
case 'G': /* GEM Application */
case 'Y': /* GEM App. with parms */
case 'F': /* File (DOS w/o parms) */
case 'P': /* Parm (DOS w/ parms) */
case 'D': /* Directory */
case 'I': /* Executable file icon */
case 'N': /* Non-executable file icon */
pa = app_alloc(TRUE);
if (!pa) /* paranoia */
return;
pcurr = app_parse(pcurr, pa);
if ((pa->a_type == AT_ISFILE) && pauto)
{ /* autorun exists & not yet merged */
if (strcmp(pauto,pa->a_pappl) == 0)
{
pa->a_flags |= AF_AUTORUN; /* it's this program */
pauto = NULL; /* (and no other) */
}
}
break;
case 'W': /* Window */
pcurr++;
if (wincnt < NUM_WNODES)
{
pws = &G.g_cnxsave.cs_wnode[wincnt];
pcurr = scan_2(pcurr, &dummy);
pcurr = scan_2(pcurr, &pws->vsl_save);
/* BugFix */
pcurr = scan_2(pcurr, &pws->x_save);
pws->x_save *= gl_wchar;
pcurr = scan_2(pcurr, &pws->y_save);
pws->y_save *= gl_hchar;
pcurr = scan_2(pcurr, &pws->w_save);
pws->w_save *= gl_wchar;
pcurr = scan_2(pcurr, &pws->h_save);
pws->h_save *= gl_hchar;
/* */
pcurr = scan_2(pcurr, &pws->obid_save);
ptmp = pws->pth_save;
pcurr++;
while(*pcurr != '@')
*ptmp++ = *pcurr++;
*ptmp = '\0';
wincnt += 1;
}
break;
case 'E': /* Environment */
pcurr++;
pcurr = scan_2(pcurr, &envr);
G.g_cnxsave.cs_view = ( (envr & INF_E1_VIEWTEXT) != 0);
G.g_cnxsave.cs_sort = ( (envr & INF_E1_SORTMASK) >> 5);
G.g_cnxsave.cs_confdel = ( (envr & INF_E1_CONFDEL) != 0);
G.g_cnxsave.cs_confcpy = ( (envr & INF_E1_CONFCPY) != 0);
G.g_cnxsave.cs_dblclick = envr & INF_E1_DCMASK;
pcurr = scan_2(pcurr, &envr);
G.g_cnxsave.cs_confovwr = ( (envr & INF_E2_ALLOWOVW) == 0);
G.g_cnxsave.cs_mnuclick = ( (envr & INF_E2_MNUCLICK) != 0);
menu_click(G.g_cnxsave.cs_mnuclick, 1); /* tell system */
if (envr & INF_E2_IDTDATE)
G.g_cnxsave.cs_datefmt = DATEFORM_IDT;
else
G.g_cnxsave.cs_datefmt = (envr & INF_E2_DAYMONTH) ? DATEFORM_DMY : DATEFORM_MDY;
if (envr & INF_E2_IDTTIME)
G.g_cnxsave.cs_timefmt = TIMEFORM_IDT;
else
G.g_cnxsave.cs_timefmt = (envr & INF_E2_24HCLOCK) ? TIMEFORM_24H : TIMEFORM_12H;
sound(FALSE, !(envr & INF_E2_SOUND), 0);
pcurr = scan_2(pcurr, &dummy); /* skip video stuff */
pcurr = scan_2(pcurr, &dummy);
pcurr = scan_2(pcurr, &envr);
if (envr & INF_E5_NOSORT)
G.g_cnxsave.cs_sort = CS_NOSORT;
break;
}
}
for (pa = G.g_ahead; pa; pa = pa->a_next)
{
if (pa->a_flags & AF_ISDESK)
{
x = pa->a_xspot * G.g_icw;
y = pa->a_yspot * G.g_ich + G.g_ydesk;
snap_disk(x, y, &pa->a_xspot, &pa->a_yspot, 0, 0);
}
}
/* set up outlines for dragging files displayed as icons */
G.g_nmicon = 9; /* number of points */
memset(G.g_xyicon, 0, sizeof(G.g_xyicon));
xcent = (G.g_wicon - G.g_iblist[0].ib_wicon) / 2;
G.g_xyicon[0] = xcent;
G.g_xyicon[2] = xcent;
G.g_xyicon[3] = G.g_hicon-gl_hschar-2;
G.g_xyicon[5] = G.g_hicon-gl_hschar-2;
G.g_xyicon[7] = G.g_hicon;
G.g_xyicon[8] = G.g_wicon;
G.g_xyicon[9] = G.g_hicon;
G.g_xyicon[10] = G.g_wicon;
G.g_xyicon[11] = G.g_hicon-gl_hschar-2;
G.g_xyicon[12] = G.g_wicon-xcent;
G.g_xyicon[13] = G.g_hicon-gl_hschar-2;
G.g_xyicon[14] = G.g_wicon-xcent;
G.g_xyicon[16] = xcent;
/* set up outlines for dragging files displayed as text */
G.g_nmtext = 5; /* number of points */
memset(G.g_xytext, 0, sizeof(G.g_xytext));
G.g_xytext[2] = gl_wchar * DRAG_BOX_WIDTH;
G.g_xytext[4] = gl_wchar * DRAG_BOX_WIDTH;
G.g_xytext[5] = gl_hchar;
G.g_xytext[7] = gl_hchar;
}
/*-----------------------------------------------------------------------------
* do_fdosboot --
*-----------------------------------------------------------------------------
*/
int do_fdosboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *name;
char *ep;
int size;
char buf [12];
int drive = CONFIG_SYS_FDC_DRIVE_NUMBER;
/* pre-set load_addr */
if ((ep = getenv("loadaddr")) != NULL) {
load_addr = simple_strtoul(ep, NULL, 16);
}
/* pre-set Boot file name */
if ((name = getenv("bootfile")) == NULL) {
name = "uImage";
}
switch (argc) {
case 1:
break;
case 2:
/* only one arg - accept two forms:
* just load address, or just boot file name.
* The latter form must be written "filename" here.
*/
if (argv[1][0] == '"') { /* just boot filename */
name = argv [1];
} else { /* load address */
load_addr = simple_strtoul(argv[1], NULL, 16);
}
break;
case 3:
load_addr = simple_strtoul(argv[1], NULL, 16);
name = argv [2];
break;
default:
return cmd_usage(cmdtp);
}
/* Init physical layer */
if (!fdc_fdos_init (drive)) {
return (-1);
}
/* Open file */
if (dos_open (name) < 0) {
printf ("Unable to open %s\n", name);
return 1;
}
if ((size = dos_read (load_addr)) < 0) {
printf ("boot error\n");
return 1;
}
flush_cache (load_addr, size);
sprintf(buf, "%x", size);
setenv("filesize", buf);
printf("Floppy DOS load complete: %d bytes loaded to 0x%lx\n",
size, load_addr);
return bootm_maybe_autostart(cmdtp, argv[0]);
}
