Return to iti.c CVS log

Up to [Research Unix] / researchv8dc / sys / dev

Annotation of researchv8dc/sys/dev/iti.c, revision 1.1.1.1

1.1       root        1: /*     %W%     */
                      2: #include "iti.h"
                      3: #include "../h/pte.h"
                      4: #include "../h/param.h"
                      5: #include "../h/dir.h"
                      6: #include "../h/user.h"
                      7: #include "../h/systm.h"
                      8: #include "../h/ioctl.h"
                      9: #include "../h/ubareg.h"
                     10: #include "../h/buf.h"
                     11: #include "../h/ubavar.h"
                     12: #include "../h/itireg.h"
                     13: int    itiprobe(), itiattach();
                     14: struct uba_device *itidinfo[NITI];
                     15: u_short        itistd[]={ 0160100, 0 };
                     16: struct uba_driver itidriver={
                     17:        itiprobe, 0, itiattach, 0, itistd, "iti", itidinfo, 0, 0
                     18: };
                     19: struct iti{
                     20:        char open;
                     21: }iti[NITI];
                     22: itiprobe(reg)
                     23: caddr_t reg;
                     24: {
                     25:        register int br=0x15, cvec=0710;                /* value-result */
                     26:        return(1);
                     27: }
                     28: /*ARGSUSED*/
                     29: itiattach(ui)
                     30: struct uba_device *ui;
                     31: {
                     32: }
                     33: itiopen(dev)
                     34: dev_t dev;
                     35: {
                     36:        register struct iti *p=&iti[minor(dev)];
                     37:        register struct uba_device *ui=itidinfo[minor(dev)];
                     38:        if(minor(dev)>=NITI || p->open || !ui->ui_alive)
                     39:                u.u_error=ENXIO;
                     40:        else{
                     41:                p->open=1;
                     42:                maptouser(ui->ui_addr);
                     43:        }
                     44: }
                     45: iticlose(dev)
                     46: dev_t dev;
                     47: {
                     48:        iti[minor(dev)].open=0;
                     49:        unmaptouser(itidinfo[minor(dev)]->ui_addr);
                     50: }
                     51: /*ARGSUSED*/
                     52: itiioctl(dev, cmd, data, flag)
                     53: dev_t dev;
                     54: int cmd;
                     55: register caddr_t data;
                     56: int flag;
                     57: {
                     58:        register struct uba_device *ui = itidinfo[minor(dev)];
                     59:        switch (cmd) {
                     60:        case ITIADDR:
                     61:                copyout((caddr_t)&ui->ui_addr, (caddr_t)data, sizeof ui->ui_addr);
                     62:                break;
                     63:        default:
                     64:                return (ENOTTY);
                     65:        }
                     66:        return (0);
                     67: }
                     68: /*ARGSUSED*/
                     69: itiintr(dev)
                     70: dev_t dev;
                     71: {}
                     72: /*
                     73:  * Map a virtual address into users address space. Actually all we
                     74:  * do is turn on the user mode write protection bits for the particular
                     75:  * page of memory involved.
                     76:  */
                     77: maptouser(vaddress)
                     78: caddr_t vaddress;
                     79: {
                     80:        Sysmap[((unsigned)vaddress-0x80000000)>>9].pg_prot=PG_UW>>27;
                     81: }
                     82: unmaptouser(vaddress)
                     83: caddr_t vaddress;
                     84: {
                     85:        Sysmap[((unsigned)vaddress-0x80000000)>>9].pg_prot=PG_KW>>27;
                     86: }

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