Return to hardfile.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

Annotation of uae/src/hardfile.c, revision 1.1

1.1     ! root        1:  /*
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   *
        !             4:   * AutoConfig devices
        !             5:   *
        !             6:   * (c) 1995 Bernd Schmidt
        !             7:   */
        !             8: 
        !             9: #include "sysconfig.h"
        !            10: #include "sysdeps.h"
        !            11: 
        !            12: #include "config.h"
        !            13: #include "options.h"
        !            14: #include "memory.h"
        !            15: #include "custom.h"
        !            16: #include "newcpu.h"
        !            17: #include "disk.h"
        !            18: #include "xwin.h"
        !            19: #include "autoconf.h"
        !            20: 
        !            21: static int opencount = 0;
        !            22: static int uaedevfd;
        !            23: int numtracks = 512;
        !            24: 
        !            25: static ULONG hardfile_init(void)
        !            26: {
        !            27:     ULONG tmp1, devicenode, bootnode;
        !            28:     int have36 = 1;
        !            29:     ULONG retval = regs.d[0];
        !            30: 
        !            31:     filesys_init();
        !            32: 
        !            33:     return retval;
        !            34: }
        !            35: 
        !            36: static ULONG hardfile_open(void)
        !            37: {
        !            38:     CPTR tmp1 = regs.a[1]; /* IOReq */
        !            39: 
        !            40:     /* Check unit number */
        !            41:     if (regs.d[0] == 0) {
        !            42:        opencount++;
        !            43:        put_word (regs.a[6]+32, get_word (regs.a[6]+32) + 1);
        !            44:        put_long (tmp1+24, 0); /* io_Unit */
        !            45:        put_byte (tmp1+31, 0); /* io_Error */
        !            46:        put_byte (tmp1+8, 7); /* ln_type = NT_REPLYMSG */
        !            47:        return 0;
        !            48:     }
        !            49: 
        !            50:     put_long (tmp1+20, (ULONG)-1);
        !            51:     put_byte (tmp1+31, (UBYTE)-1);
        !            52:     return (ULONG)-1;
        !            53: }
        !            54: 
        !            55: static ULONG hardfile_close(void)
        !            56: {
        !            57:     opencount--;
        !            58:     put_word (regs.a[6]+32, get_word (regs.a[6]+32) - 1);
        !            59: 
        !            60:     return regs.d[0];
        !            61: }
        !            62: 
        !            63: static ULONG hardfile_expunge(void)
        !            64: {
        !            65:     return 0; /* Simply ignore this one... */
        !            66: }
        !            67: 
        !            68: static ULONG hardfile_beginio(void)
        !            69: {
        !            70:     ULONG tmp1, tmp2, dataptr, offset;
        !            71:     ULONG retval = regs.d[0];
        !            72: 
        !            73:     tmp1 = regs.a[1];
        !            74:     put_byte (tmp1+8, 5); /* set ln_type to NT_MESSAGE */
        !            75:     put_byte (tmp1+31, 0); /* no error yet */
        !            76:     tmp2 = get_word (tmp1+28); /* io_Command */
        !            77:     switch (tmp2) {
        !            78:      case 2: /* Read */
        !            79:        dataptr = get_long (tmp1 + 40);
        !            80:        if (dataptr & 1)
        !            81:            goto bad_command;
        !            82:        offset = get_long (tmp1 + 44);
        !            83:        if (offset & 511)
        !            84:            goto bad_command;
        !            85:        tmp2 = get_long (tmp1 + 36); /* io_Length */
        !            86:        if (tmp2 & 511)
        !            87:            goto bad_command;
        !            88:        if (tmp2 + offset > (ULONG)numtracks * 32 * 512)
        !            89:            goto bad_command;
        !            90: 
        !            91:        put_long (tmp1 + 32, tmp2); /* set io_Actual */
        !            92:        lseek (uaedevfd, offset, SEEK_SET);
        !            93:        while (tmp2) {
        !            94:            int i;
        !            95:            char buffer[512];
        !            96:            read (uaedevfd, buffer, 512);
        !            97:            for (i = 0; i < 512; i++, dataptr++)
        !            98:                put_byte(dataptr, buffer[i]);
        !            99:            tmp2 -= 512;
        !           100:        }
        !           101:        break;
        !           102: 
        !           103:      case 3: /* Write */
        !           104:      case 11: /* Format */
        !           105:        dataptr = get_long (tmp1 + 40);
        !           106:        if (dataptr & 1)
        !           107:            goto bad_command;
        !           108:        offset = get_long (tmp1 + 44);
        !           109:        if (offset & 511)
        !           110:            goto bad_command;
        !           111:        tmp2 = get_long (tmp1 + 36); /* io_Length */
        !           112:        if (tmp2 & 511)
        !           113:            goto bad_command;
        !           114:        if (tmp2 + offset > (ULONG)numtracks * 32 * 512)
        !           115:            goto bad_command;
        !           116: 
        !           117:        put_long (tmp1 + 32, tmp2); /* set io_Actual */
        !           118:        lseek (uaedevfd, offset, SEEK_SET);
        !           119:        while (tmp2) {
        !           120:            char buffer[512];
        !           121:            int i;
        !           122:            for (i=0; i < 512; i++, dataptr++)
        !           123:                buffer[i] = get_byte(dataptr);
        !           124:            write (uaedevfd, buffer, 512);
        !           125:            tmp2 -= 512;
        !           126:        }
        !           127:        break;
        !           128: 
        !           129:        bad_command:
        !           130:        break;
        !           131: 
        !           132:      case 18: /* GetDriveType */
        !           133:        put_long (tmp1 + 32, 1); /* not exactly a 3.5" drive, but... */
        !           134:        break;
        !           135: 
        !           136:      case 19: /* GetNumTracks */
        !           137:        put_long (tmp1 + 32, numtracks);
        !           138:        break;
        !           139: 
        !           140:        /* Some commands that just do nothing and return zero */
        !           141:      case 4: /* Update */
        !           142:      case 5: /* Clear */
        !           143:      case 9: /* Motor */
        !           144:      case 10: /* Seek */
        !           145:      case 12: /* Remove */
        !           146:      case 13: /* ChangeNum */
        !           147:      case 14: /* ChangeStatus */
        !           148:      case 15: /* ProtStatus */
        !           149:      case 20: /* AddChangeInt */
        !           150:      case 21: /* RemChangeInt */
        !           151:        put_long (tmp1+32, 0); /* io_Actual */
        !           152:        retval = 0;
        !           153:        break;
        !           154: 
        !           155:      default:
        !           156:        /* Command not understood. */
        !           157:        put_byte (tmp1+31, (UBYTE)-3); /* io_Error */
        !           158:        retval = 0;
        !           159:        break;
        !           160:     }
        !           161:     if ((get_byte (tmp1+30) & 1) == 0) {
        !           162:        /* Not IOF_QUICK -- need to ReplyMsg */
        !           163:        regs.a[1] = tmp1;
        !           164:        CallLib (get_long(4), -378);
        !           165:     }
        !           166:     return retval;
        !           167: }
        !           168: 
        !           169: static ULONG hardfile_abortio(void)
        !           170: {
        !           171:     return (ULONG)-3;
        !           172: }
        !           173: 
        !           174: void hardfile_install(void)
        !           175: {
        !           176:     ULONG functable, datatable, inittable;
        !           177:     ULONG initcode, openfunc, closefunc, expungefunc;
        !           178:     ULONG nullfunc, beginiofunc, abortiofunc;
        !           179: 
        !           180:     uaedevfd = open ("hardfile", O_RDWR | O_BINARY);
        !           181: 
        !           182:     ROM_hardfile_resname = ds("hardfile.device");
        !           183:     ROM_hardfile_resid = ds("UAE hardfile.device 0.2");
        !           184: 
        !           185:     numtracks = hardfile_size / 16384;
        !           186: 
        !           187:     /* initcode */
        !           188:     initcode = here();
        !           189:     calltrap(deftrap(hardfile_init)); dw(RTS);
        !           190: 
        !           191:     /* Open */
        !           192:     openfunc = here();
        !           193:     calltrap(deftrap(hardfile_open)); dw(RTS);
        !           194: 
        !           195:     /* Close */
        !           196:     closefunc = here();
        !           197:     calltrap(deftrap(hardfile_close)); dw(RTS);
        !           198: 
        !           199:     /* Expunge */
        !           200:     expungefunc = here();
        !           201:     calltrap(deftrap(hardfile_expunge)); dw(RTS);
        !           202: 
        !           203:     /* Null */
        !           204:     nullfunc = here();
        !           205:     dw(0x7000); /* return 0; */
        !           206:     dw(RTS);
        !           207: 
        !           208:     /* BeginIO */
        !           209:     beginiofunc = here();
        !           210:     calltrap(deftrap(hardfile_beginio)); dw(RTS);
        !           211: 
        !           212:     /* AbortIO */
        !           213:     abortiofunc = here();
        !           214:     calltrap(deftrap(hardfile_abortio)); dw(RTS);
        !           215: 
        !           216:     /* FuncTable */
        !           217:     functable = here();
        !           218:     dl(openfunc); /* Open */
        !           219:     dl(closefunc); /* Close */
        !           220:     dl(expungefunc); /* Expunge */
        !           221:     dl(nullfunc); /* Null */
        !           222:     dl(beginiofunc); /* BeginIO */
        !           223:     dl(abortiofunc); /* AbortIO */
        !           224:     dl(0xFFFFFFFF); /* end of table */
        !           225: 
        !           226:     /* DataTable */
        !           227:     datatable = here();
        !           228:     dw(0xE000); /* INITBYTE */
        !           229:     dw(0x0008); /* LN_TYPE */
        !           230:     dw(0x0300); /* NT_DEVICE */
        !           231:     dw(0xC000); /* INITLONG */
        !           232:     dw(0x000A); /* LN_NAME */
        !           233:     dl(ROM_hardfile_resname);
        !           234:     dw(0xE000); /* INITBYTE */
        !           235:     dw(0x000E); /* LIB_FLAGS */
        !           236:     dw(0x0600); /* LIBF_SUMUSED | LIBF_CHANGED */
        !           237:     dw(0xD000); /* INITWORD */
        !           238:     dw(0x0014); /* LIB_VERSION */
        !           239:     dw(0x0004); /* 0.4 */
        !           240:     dw(0xD000);
        !           241:     dw(0x0016); /* LIB_REVISION */
        !           242:     dw(0x0000);
        !           243:     dw(0xC000);
        !           244:     dw(0x0018); /* LIB_IDSTRING */
        !           245:     dl(ROM_hardfile_resid);
        !           246:     dw(0x0000); /* end of table */
        !           247: 
        !           248:     ROM_hardfile_init = here();
        !           249:     dl(0x00000100); /* ??? */
        !           250:     dl(functable);
        !           251:     dl(datatable);
        !           252:     dl(initcode);
        !           253: 
        !           254:     if (uaedevfd >= 0) {
        !           255:        CPTR initfunc;
        !           256:        
        !           257:        add_filesys_unit(NULL, "hardfile", 1);
        !           258:     }
        !           259: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.