Return to f002550 CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/f002550, revision 1.1.1.1

1.1       root        1: /*
                      2:  *  template for making a new device
                      3:  */
                      4: 
                      5: #include       "u.h"
                      6: #include       "../port/lib.h"
                      7: #include       "mem.h"
                      8: #include       "dat.h"
                      9: #include       "fns.h"
                     10: #include       "../port/error.h"
                     11: 
                     12: #include       "devtab.h"
                     13: 
                     14: enum{
                     15:        XXXdirqid,
                     16:        XXXdataqid,
                     17: };
                     18: Dirtab XXXtab[]={
                     19:        "data",         {XXXdataqid, 0},        0,      0600,
                     20: };
                     21: #define NXXXtab (sizeof(XXXtab)/sizeof(Dirtab))
                     22: 
                     23: void
                     24: XXXreset(void)
                     25: {
                     26: }
                     27: 
                     28: void
                     29: XXXinit(void)
                     30: {
                     31: }
                     32: 
                     33: Chan *
                     34: XXXattach(char *spec)
                     35: {
                     36:        return devattach('X', spec);
                     37: }
                     38: 
                     39: Chan *
                     40: XXXclone(Chan *c, Chan *nc)
                     41: {
                     42:        return devclone(c, nc);
                     43: }
                     44: 
                     45: int
                     46: XXXwalk(Chan *c, char *name)
                     47: {
                     48:        return devwalk(c, name, XXXtab, NXXXtab, devgen);
                     49: }
                     50: 
                     51: void
                     52: XXXstat(Chan *c, char *db)
                     53: {
                     54:        devstat(c, db, XXXtab, NXXXtab, devgen);
                     55: }
                     56: 
                     57: Chan *
                     58: XXXopen(Chan *c, int omode)
                     59: {
                     60:        return devopen(c, omode, XXXtab, NXXXtab, devgen);
                     61: }
                     62: 
                     63: void
                     64: XXXcreate(Chan *c, char *name, int omode, ulong perm)
                     65: {
                     66:        USED(c, name, omode, perm);
                     67:        error(Eperm);
                     68: }
                     69: 
                     70: void
                     71: XXXremove(Chan *c)
                     72: {
                     73:        USED(c);
                     74:        error(Eperm);
                     75: }
                     76: 
                     77: void
                     78: XXXwstat(Chan *c, char *dp)
                     79: {
                     80:        USED(c, dp);
                     81:        error(Eperm);
                     82: }
                     83: 
                     84: void
                     85: XXXclose(Chan *c)
                     86: {
                     87: }
                     88: 
                     89: long
                     90: XXXread(Chan *c, void *a, long n, ulong offset)
                     91: {
                     92:        switch(c->qid.path & ~CHDIR){
                     93:        case XXXdirqid:
                     94:                return devdirread(c, a, n, XXXtab, NXXXtab, devgen);
                     95:        case XXXdataqid:
                     96:                break;
                     97:        default:
                     98:                n=0;
                     99:                break;
                    100:        }
                    101:        return n;
                    102: }
                    103: 
                    104: long
                    105: XXXwrite(Chan *c, char *a, long n, ulong offset)
                    106: {
                    107:        switch(c->qid.path & ~CHDIR){
                    108:        case XXXdataqid:
                    109:                break;
                    110:        default:
                    111:                error(Ebadusefd);
                    112:        }
                    113:        return n;
                    114: }

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