![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to biosfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to biosfs.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: Copyright 1991,1992 Eric R. Smith. All rights reserved.
4:
5: */
6:
7:
8:
9: /* simple biosfs.c */
10:
11:
12:
13: #include "mint.h"
14:
15:
16:
17: extern struct kerinfo kernelinfo; /* see main.c */
18:
19:
20:
21: static long bios_root P_((int drv, fcookie *fc));
22:
23: static long bios_lookup P_((fcookie *dir, const char *name, fcookie *fc));
24:
25: static long bios_getxattr P_((fcookie *fc, XATTR *xattr));
26:
27: static long bios_chattr P_((fcookie *fc, int attrib));
28:
29: static long bios_chown P_((fcookie *fc, int uid, int gid));
30:
31: static long bios_chmode P_((fcookie *fc, unsigned mode));
32:
33: static long bios_rmdir P_((fcookie *dir, const char *name));
34:
35: static long bios_remove P_((fcookie *dir, const char *name));
36:
37: static long bios_getname P_((fcookie *root, fcookie *dir, char *pathname));
38:
39: static long bios_rename P_((fcookie *olddir, char *oldname,
40:
41: fcookie *newdir, const char *newname));
42:
43: static long bios_opendir P_((DIR *dirh, int flags));
44:
45: static long bios_readdir P_((DIR *dirh, char *nm, int nmlen, fcookie *fc));
46:
47: static long bios_rewinddir P_((DIR *dirh));
48:
49: static long bios_closedir P_((DIR *dirh));
50:
51: static long bios_pathconf P_((fcookie *dir, int which));
52:
53: static long bios_dfree P_((fcookie *dir, long *buf));
54:
55: static DEVDRV * bios_getdev P_((fcookie *fc, long *devspecial));
56:
57: static long bios_fscntl P_((fcookie *, const char *, int, long));
58:
59: static long bios_symlink P_((fcookie *, const char *, const char *));
60:
61: static long bios_readlink P_((fcookie *, char *, int));
62:
63:
64:
65: static long bios_topen P_((FILEPTR *f));
66:
67: static long bios_twrite P_((FILEPTR *f, const char *buf, long bytes));
68:
69: static long bios_tread P_((FILEPTR *f, char *buf, long bytes));
70:
71: static long bios_nwrite P_((FILEPTR *f, const char *buf, long bytes));
72:
73: static long bios_nread P_((FILEPTR *f, char *buf, long bytes));
74:
75: static long bios_ioctl P_((FILEPTR *f, int mode, void *buf));
76:
77: static long bios_select P_((FILEPTR *f, long p, int mode));
78:
79: static void bios_unselect P_((FILEPTR *f, long p, int mode));
80:
81: static long bios_tseek P_((FILEPTR *f, long where, int whence));
82:
83:
84:
85: long null_open P_((FILEPTR *f));
86:
87: long null_write P_((FILEPTR *f, const char *buf, long bytes));
88:
89: long null_read P_((FILEPTR *f, char *buf, long bytes));
90:
91: long null_lseek P_((FILEPTR *f, long where, int whence));
92:
93: long null_ioctl P_((FILEPTR *f, int mode, void *buf));
94:
95: long null_datime P_((FILEPTR *f, short *time, int rwflag));
96:
97: long null_close P_((FILEPTR *f, int pid));
98:
99: long null_select P_((FILEPTR *f, long p, int mode));
100:
101: void null_unselect P_((FILEPTR *f, long p, int mode));
102:
103:
104:
105: static long mouse_open P_((FILEPTR *f));
106:
107: static long mouse_read P_((FILEPTR *f, char *buf, long nbytes));
108:
109: static long mouse_ioctl P_((FILEPTR *f, int mode, void *buf));
110:
111: static long mouse_close P_((FILEPTR *f, int pid));
112:
113: static long mouse_select P_((FILEPTR *f, long p, int mode));
114:
115: static void mouse_unselect P_((FILEPTR *f, long p, int mode));
116:
117:
118:
119: /* device driver for BIOS terminals */
120:
121:
122:
123: DEVDRV bios_tdevice = {
124:
125: bios_topen, bios_twrite, bios_tread, bios_tseek, bios_ioctl,
126:
127: null_datime, null_close, bios_select, bios_unselect
128:
129: };
130:
131:
132:
133: /* device driver for BIOS devices that are not terminals */
134:
135:
136:
137: DEVDRV bios_ndevice = {
138:
139: null_open, bios_nwrite, bios_nread, null_lseek, bios_ioctl,
140:
141: null_datime, null_close, bios_select, bios_unselect
142:
143: };
144:
145:
146:
147: DEVDRV null_device = {
148:
149: null_open, null_write, null_read, null_lseek, null_ioctl,
150:
151: null_datime, null_close, null_select, null_unselect
152:
153: };
154:
155:
156:
157: DEVDRV mouse_device = {
158:
159: mouse_open, null_write, mouse_read, null_lseek, mouse_ioctl,
160:
161: null_datime, mouse_close, mouse_select, mouse_unselect
162:
163: };
164:
165:
166:
167: /* this special driver is checked for in dosfile.c, and indicates that
168:
169: * a dup operation is actually wanted rather than an open
170:
171: */
172:
173: DEVDRV fakedev;
174:
175:
176:
177: #ifdef FASTTEXT
178:
179: extern DEVDRV screen_device; /* see fasttext.c */
180:
181: #endif
182:
183:
184:
185: FILESYS bios_filesys = {
186:
187: (FILESYS *)0,
188:
189: 0,
190:
191: bios_root,
192:
193: bios_lookup, nocreat, bios_getdev, bios_getxattr,
194:
195: bios_chattr, bios_chown, bios_chmode,
196:
197: nomkdir, bios_rmdir, bios_remove, bios_getname, bios_rename,
198:
199: bios_opendir, bios_readdir, bios_rewinddir, bios_closedir,
200:
201: bios_pathconf, bios_dfree, nowritelabel, noreadlabel,
202:
203: bios_symlink, bios_readlink, nohardlink, bios_fscntl, nodskchng
204:
205: };
206:
207:
208:
209:
210:
211: struct tty con_tty, aux_tty, midi_tty;
212:
213: struct tty sccb_tty, scca_tty, ttmfp_tty;
214:
215:
216:
217: #define BNAME_MAX 13
218:
219:
220:
221: struct bios_file {
222:
223: char name[BNAME_MAX+1]; /* device name */
224:
225: DEVDRV *device; /* device driver for device */
226:
227: short private; /* extra info for device driver */
228:
229: ushort flags; /* flags for device open */
230:
231: struct tty *tty; /* tty structure (if appropriate) */
232:
233: struct bios_file *next;
234:
235: };
236:
237:
238:
239: struct bios_file BDEV[] = {
240:
241:
242:
243: /* "real" bios devices present on all machines */
244:
245: {"centr", &bios_ndevice, 0, 0, 0, 0},
246:
247: {"console", &bios_tdevice, 2, O_TTY, &con_tty, 0},
248:
249: {"midi", &bios_tdevice, 3, O_TTY, &midi_tty, 0},
250:
251: {"kbd", &bios_ndevice, 4, 0, 0, 0},
252:
253: /* devices that duplicate handles */
254:
255: {"prn", &fakedev, -3, 0, 0, 0}, /* handle -3 (printer) */
256:
257: {"aux", &fakedev, -2, 0, 0, 0}, /* handle -2 (aux. terminal) */
258:
259: {"con", &fakedev, -1, 0, 0, 0}, /* handle -1 (control terminal) */
260:
261: {"tty", &fakedev, -1, 0, 0, 0}, /* the Unix name for it */
262:
263: {"stdin", &fakedev, 0, 0, 0, 0}, /* handle 0 (stdin) */
264:
265: {"stdout", &fakedev, 1, 0, 0, 0}, /* handle 1 (stdout) */
266:
267: {"stderr", &fakedev, 2, 0, 0, 0}, /* handle 2 (stderr) */
268:
269:
270:
271: /* other miscellaneous devices */
272:
273: {"mouse", &mouse_device, 0, 0, 0, 0},
274:
275: {"null", &null_device, 0, 0, 0, 0},
276:
277:
278:
279: #ifdef FASTTEXT
280:
281: /* alternate console driver */
282:
283: {"fasttext", &screen_device, 2, O_TTY, &con_tty, 0},
284:
285: #endif
286:
287:
288:
289: /* serial port things *must* come last, because not all of these
290:
291: * are present on all machines (except for modem1, which does however
292:
293: * have a different device number on TTs and STs)
294:
295: */
296:
297: {"modem1", &bios_tdevice, 6, O_TTY, &aux_tty, 0},
298:
299: {"modem2", &bios_tdevice, 7, O_TTY, &sccb_tty, 0},
300:
301: {"serial1", &bios_tdevice, 8, O_TTY, &ttmfp_tty, 0},
302:
303: {"serial2", &bios_tdevice, 9, O_TTY, &scca_tty, 0},
304:
305: {"", 0, 0, 0, 0, 0}
306:
307: };
308:
309:
310:
311: struct bios_file *broot, *bdevlast;
312:
313:
314:
315: /* a file pointer for BIOS device 1, provided only for insurance
316:
317: * in case a Bconmap happens and we can't allocate a new FILEPTR;
318:
319: * in most cases, we'll want to build a FILEPTR in the usual
320:
321: * way.
322:
323: */
324:
325:
326:
327: FILEPTR *defaultaux;
328:
329:
330:
331: void
332:
333: biosfs_init()
334:
335: {
336:
337: struct bios_file *b;
338:
339:
340:
341: broot = BDEV;
342:
343:
344:
345: for (b = broot; b->name[0]; b++) {
346:
347: b->next = b+1;
348:
349:
350:
351: /* if not a TT or Mega STE, adjust the MODEM1 device to be BIOS
352:
353: * device 1
354:
355: * and ignore the remaining devices, since they're not present
356:
357: */
358:
359: if (!has_bconmap && b->private == 6) {
360:
361: b->private = 1;
362:
363: b->next = 0;
364:
365: break;
366:
367: }
368:
369: /* SERIAL2 is not present on the Mega STe */
370:
371: if (mch == MEGASTE && b->private == 8) {
372:
373: b->next = 0;
374:
375: break;
376:
377: }
378:
379:
380:
381: }
382:
383: bdevlast = b;
384:
385: if (b->name[0] == 0) {
386:
387: --b;
388:
389: b->next = 0;
390:
391: }
392:
393: defaultaux = new_fileptr();
394:
395: defaultaux->links = 1; /* so it never gets freed */
396:
397: defaultaux->flags = O_RDWR;
398:
399: defaultaux->pos = 0;
400:
401: defaultaux->devinfo = 0;
402:
403: defaultaux->fc.fs = &bios_filesys;
404:
405: defaultaux->fc.index = 0;
406:
407: defaultaux->fc.aux = 1;
408:
409: defaultaux->fc.dev = BIOSDRV;
410:
411: defaultaux->dev = &bios_ndevice;
412:
413: }
414:
415:
416:
417: static long
418:
419: bios_root(drv, fc)
420:
421: int drv;
422:
423: fcookie *fc;
424:
425: {
426:
427: if (drv == BIOSDRV) {
428:
429: fc->fs = &bios_filesys;
430:
431: fc->dev = drv;
432:
433: fc->index = 0L;
434:
435: return 0;
436:
437: }
438:
439: fc->fs = 0;
440:
441: return EINTRN;
442:
443: }
444:
445:
446:
447: static long
448:
449: bios_lookup(dir, name, fc)
450:
451: fcookie *dir;
452:
453: const char *name;
454:
455: fcookie *fc;
456:
457: {
458:
459: struct bios_file *b;
460:
461:
462:
463: TRACE("bios_lookup(%s)", name);
464:
465:
466:
467: if (dir->index != 0) {
468:
469: DEBUG("bios_lookup: bad directory");
470:
471: return EPTHNF;
472:
473: }
474:
475: /* special case: an empty name in a directory means that directory */
476:
477: /* so does "." */
478:
479: if (!*name || (name[0] == '.' && name[1] == 0)) {
480:
481: *fc = *dir;
482:
483: return 0;
484:
485: }
486:
487:
488:
489: /* another special case: ".." could be a mount point */
490:
491: if (!strcmp(name, "..")) {
492:
493: *fc = *dir;
494:
495: return EMOUNT;
496:
497: }
498:
499:
500:
501: for (b = broot; b; b = b->next) {
502:
503: if (!stricmp(b->name, name)) {
504:
505: fc->fs = &bios_filesys;
506:
507: fc->index = (long)b;
508:
509: fc->aux = b->private;
510:
511: fc->dev = dir->dev;
512:
513: return 0;
514:
515: }
516:
517: }
518:
519: DEBUG("bios_lookup: name(%s) not found", name);
520:
521: return EFILNF;
522:
523: }
524:
525:
526:
527: static long
528:
529: bios_getxattr(fc, xattr)
530:
531: fcookie *fc;
532:
533: XATTR *xattr;
534:
535: {
536:
537: struct bios_file *b = (struct bios_file *)fc->index;
538:
539:
540:
541: xattr->index = fc->index;
542:
543: xattr->dev = fc->dev;
544:
545: xattr->nlink = 1;
546:
547: xattr->uid = xattr->gid = 0;
548:
549: xattr->size = xattr->nblocks = 0;
550:
551: xattr->blksize = 1;
552:
553: xattr->mtime = xattr->atime = xattr->ctime = timestamp;
554:
555: xattr->mdate = xattr->adate = xattr->cdate = datestamp;
556:
557: if (fc->index == 0) { /* root directory? */
558:
559: xattr->mode = S_IFDIR | DEFAULT_DIRMODE;
560:
561: xattr->attr = FA_DIR;
562:
563: } else if (b->device == 0) { /* symbolic link? */
564:
565: xattr->mode = S_IFLNK | DEFAULT_DIRMODE;
566:
567: } else {
568:
569: /* BUG: U:\DEV\STDIN, U:\DEV\STDOUT, etc. might not be terminal files */
570:
571: xattr->mode = S_IFCHR | DEFAULT_MODE;
572:
573: xattr->attr = 0;
574:
575: }
576:
577: return 0;
578:
579: }
580:
581:
582:
583: static long
584:
585: bios_chattr(fc, attrib)
586:
587: fcookie *fc;
588:
589: int attrib;
590:
591: {
592:
593: return EACCDN;
594:
595: }
596:
597:
598:
599: static long
600:
601: bios_chown(fc, uid, gid)
602:
603: fcookie *fc;
604:
605: int uid, gid;
606:
607: {
608:
609: return EINVFN;
610:
611: }
612:
613:
614:
615: static long
616:
617: bios_chmode(fc, mode)
618:
619: fcookie *fc;
620:
621: unsigned mode;
622:
623: {
624:
625: return EINVFN;
626:
627: }
628:
629:
630:
631: long
632:
633: nomkdir(dir, name, mode)
634:
635: fcookie *dir;
636:
637: const char *name;
638:
639: unsigned mode;
640:
641: {
642:
643: return EACCDN;
644:
645: }
646:
647:
648:
649: static long
650:
651: bios_rmdir(dir, name)
652:
653: fcookie *dir;
654:
655: const char *name;
656:
657: {
658:
659: return bios_remove(dir, name);
660:
661: }
662:
663:
664:
665: /*
666:
667: * MAJOR BUG: we don't check here for removal of devices for which there
668:
669: * are still open files
670:
671: */
672:
673:
674:
675: static long
676:
677: bios_remove(dir, name)
678:
679: fcookie *dir;
680:
681: const char *name;
682:
683: {
684:
685: struct bios_file *b, **lastb;
686:
687:
688:
689: lastb = &broot;
690:
691: for (b = broot; b; b = *(lastb = &b->next)) {
692:
693: if (!stricmp(b->name, name)) break;
694:
695: }
696:
697: if (!b) return EFILNF;
698:
699:
700:
701: /* don't allow removal of the basic system devices */
702:
703: if (b >= BDEV && b <= bdevlast) {
704:
705: return EACCDN;
706:
707: }
708:
709: *lastb = b->next;
710:
711:
712:
713: if (b->device == 0 || b->device == &bios_tdevice)
714:
715: kfree(b->tty);
716:
717:
718:
719: kfree(b);
720:
721: return 0;
722:
723: }
724:
725:
726:
727: static long
728:
729: bios_getname(root, dir, pathname)
730:
731: fcookie *root, *dir; char *pathname;
732:
733: {
734:
735: if (dir->index == 0)
736:
737: *pathname = 0;
738:
739: else
740:
741: strcpy(pathname, ((struct bios_file *)dir->index)->name);
742:
743: return 0;
744:
745: }
746:
747:
748:
749: static long
750:
751: bios_rename(olddir, oldname, newdir, newname)
752:
753: fcookie *olddir;
754:
755: char *oldname;
756:
757: fcookie *newdir;
758:
759: const char *newname;
760:
761: {
762:
763: struct bios_file *b;
764:
765:
766:
767: /* BUG: we should check to see if "newname" already exists */
768:
769:
770:
771: for (b = broot; b; b = b->next) {
772:
773: if (!stricmp(b->name, oldname)) {
774:
775: strncpy(b->name, newname, BNAME_MAX);
776:
777: return 0;
778:
779: }
780:
781: }
782:
783: return EFILNF;
784:
785: }
786:
787:
788:
789: static long
790:
791: bios_opendir(dirh, flags)
792:
793: DIR *dirh;
794:
795: int flags;
796:
797: {
798:
799: if (dirh->fc.index != 0) {
800:
801: DEBUG("bios_opendir: bad directory");
802:
803: return EPTHNF;
804:
805: }
806:
807: return 0;
808:
809: }
810:
811:
812:
813: static long
814:
815: bios_readdir(dirh, name, namelen, fc)
816:
817: DIR *dirh;
818:
819: char *name;
820:
821: int namelen;
822:
823: fcookie *fc;
824:
825: {
826:
827: struct bios_file *b;
828:
829: int giveindex = dirh->flags == 0;
830:
831: int i;
832:
833:
834:
835: b = broot;
836:
837: i = dirh->index++;
838:
839: while(i-- > 0) {
840:
841: if (!b) break;
842:
843: b = b->next;
844:
845: }
846:
847: if (!b) {
848:
849: return ENMFIL;
850:
851: }
852:
853: fc->fs = &bios_filesys;
854:
855: fc->index = (long)b;
856:
857: fc->aux = b->private;
858:
859: fc->dev = dirh->fc.dev;
860:
861: if (giveindex) {
862:
863: namelen -= sizeof(long);
864:
865: if (namelen <= 0)
866:
867: return ERANGE;
868:
869: *((long *)name) = (long) b;
870:
871: name += sizeof(long);
872:
873: }
874:
875: strncpy(name, b->name, namelen-1);
876:
877: if (strlen(b->name) >= namelen)
878:
879: return ENAMETOOLONG;
880:
881: return 0;
882:
883: }
884:
885:
886:
887: static long
888:
889: bios_rewinddir(dirh)
890:
891: DIR *dirh;
892:
893: {
894:
895: dirh->index = 0;
896:
897: return 0;
898:
899: }
900:
901:
902:
903: static long
904:
905: bios_closedir(dirh)
906:
907: DIR *dirh;
908:
909: {
910:
911: return 0;
912:
913: }
914:
915:
916:
917: static long
918:
919: bios_pathconf(dir, which)
920:
921: fcookie *dir;
922:
923: int which;
924:
925: {
926:
927: switch(which) {
928:
929: case -1:
930:
931: return DP_MAXREQ;
932:
933: case DP_IOPEN:
934:
935: return UNLIMITED; /* no limit on BIOS file descriptors */
936:
937: case DP_MAXLINKS:
938:
939: return 1; /* no hard links available */
940:
941: case DP_PATHMAX:
942:
943: return PATH_MAX;
944:
945: case DP_NAMEMAX:
946:
947: return BNAME_MAX;
948:
949: case DP_ATOMIC:
950:
951: return 1; /* no atomic writes */
952:
953: case DP_TRUNC:
954:
955: return DP_AUTOTRUNC; /* names are truncated */
956:
957: case DP_CASE:
958:
959: return DP_CASEINSENS; /* not case sensitive */
960:
961: default:
962:
963: return EINVFN;
964:
965: }
966:
967: }
968:
969:
970:
971: static long
972:
973: bios_dfree(dir, buf)
974:
975: fcookie *dir;
976:
977: long *buf;
978:
979: {
980:
981: buf[0] = 0; /* number of free clusters */
982:
983: buf[1] = 0; /* total number of clusters */
984:
985: buf[2] = 1; /* sector size (bytes) */
986:
987: buf[3] = 1; /* cluster size (sectors) */
988:
989: return 0;
990:
991: }
992:
993:
994:
995: /*
996:
997: * BIOS Dcntl() calls:
998:
999: * Dcntl(0xde02, "U:\DEV\FOO", &foo_descr): install a new device called
1000:
1001: * "FOO", which is described by the dev_descr structure "foo_descr".
1002:
1003: * this structure has the following fields:
1004:
1005: * DEVDRV *driver the device driver itself
1006:
1007: * short dinfo info for the device driver
1008:
1009: * short flags flags for the file (e.g. O_TTY)
1010:
1011: * struct tty *tty tty structure, if appropriate
1012:
1013: *
1014:
1015: * Dcntl(0xde00, "U:\DEV\BAR", n): install a new BIOS terminal device, with
1016:
1017: * BIOS device number "n".
1018:
1019: * Dcntl(0xde01, "U:\DEV\BAR", n): install a new non-tty BIOS device, with
1020:
1021: * BIOS device number "n".
1022:
1023: */
1024:
1025:
1026:
1027: static long
1028:
1029: bios_fscntl(dir, name, cmd, arg)
1030:
1031: fcookie *dir;
1032:
1033: const char *name;
1034:
1035: int cmd;
1036:
1037: long arg;
1038:
1039: {
1040:
1041: struct bios_file *b;
1042:
1043:
1044:
1045: if (cmd == DEV_INSTALL) {
1046:
1047: struct dev_descr *d = (struct dev_descr *)arg;
1048:
1049:
1050:
1051: b = kmalloc(SIZEOF(struct bios_file));
1052:
1053: if (!b) return 0;
1054:
1055: strncpy(b->name, name, BNAME_MAX);
1056:
1057: b->name[BNAME_MAX] = 0;
1058:
1059: b->device = d->driver;
1060:
1061: b->private = d->dinfo;
1062:
1063: b->flags = d->flags;
1064:
1065: b->tty = d->tty;
1066:
1067: b->next = broot;
1068:
1069: broot = b;
1070:
1071: return (long)&kernelinfo;
1072:
1073: }
1074:
1075: if (cmd == DEV_NEWTTY) {
1076:
1077: b = kmalloc(SIZEOF(struct bios_file));
1078:
1079: if (!b) return ENSMEM;
1080:
1081: b->tty = kmalloc(SIZEOF(struct tty));
1082:
1083: if (!b->tty) {
1084:
1085: kfree(b);
1086:
1087: return ENSMEM;
1088:
1089: }
1090:
1091: strncpy(b->name, name, BNAME_MAX);
1092:
1093: b->name[BNAME_MAX] = 0;
1094:
1095: b->device = &bios_tdevice;
1096:
1097: b->private = arg;
1098:
1099: b->flags = O_TTY;
1100:
1101: *b->tty = default_tty;
1102:
1103: b->next = broot;
1104:
1105: broot = b;
1106:
1107: return 0;
1108:
1109: }
1110:
1111: if (cmd == DEV_NEWBIOS) {
1112:
1113: b = kmalloc(SIZEOF(struct bios_file));
1114:
1115: if (!b) return ENSMEM;
1116:
1117: strncpy(b->name, name, BNAME_MAX);
1118:
1119: b->name[BNAME_MAX] = 0;
1120:
1121: b->tty = 0;
1122:
1123: b->device = &bios_ndevice;
1124:
1125: b->private = arg;
1126:
1127: b->flags = 0;
1128:
1129: b->next = broot;
1130:
1131: return 0;
1132:
1133: }
1134:
1135: return EINVFN;
1136:
1137: }
1138:
1139:
1140:
1141: static long
1142:
1143: bios_symlink(dir, name, to)
1144:
1145: fcookie *dir;
1146:
1147: const char *name, *to;
1148:
1149: {
1150:
1151: struct bios_file *b;
1152:
1153: long r;
1154:
1155: fcookie fc;
1156:
1157:
1158:
1159: r = bios_lookup(dir, name, &fc);
1160:
1161: if (r == 0) return EACCDN; /* file already exists */
1162:
1163: if (r != EFILNF) return r; /* some other error */
1164:
1165:
1166:
1167: b = kmalloc(SIZEOF(struct bios_file));
1168:
1169: if (!b) return EACCDN;
1170:
1171:
1172:
1173: strncpy(b->name, name, BNAME_MAX);
1174:
1175: b->name[BNAME_MAX] = 0;
1176:
1177: b->device = 0;
1178:
1179: b->private = EINVFN;
1180:
1181: b->flags = 0;
1182:
1183: b->tty = kmalloc((long)strlen(to)+1);
1184:
1185: if (!b->tty) {
1186:
1187: kfree(b);
1188:
1189: return EACCDN;
1190:
1191: }
1192:
1193: strcpy((char *)b->tty, to);
1194:
1195: b->next = broot;
1196:
1197: broot = b;
1198:
1199: return 0;
1200:
1201: }
1202:
1203:
1204:
1205: static long
1206:
1207: bios_readlink(fc, buf, buflen)
1208:
1209: fcookie *fc;
1210:
1211: char *buf;
1212:
1213: int buflen;
1214:
1215: {
1216:
1217: struct bios_file *b = (struct bios_file *)fc->index;
1218:
1219:
1220:
1221: if (!b) return EINVFN;
1222:
1223: if (b->device) return EINVFN;
1224:
1225:
1226:
1227: strncpy(buf, (char *)b->tty, buflen);
1228:
1229: if (strlen((char *)b->tty) >= buflen)
1230:
1231: return ENAMETOOLONG;
1232:
1233: return 0;
1234:
1235: }
1236:
1237:
1238:
1239:
1240:
1241: /*
1242:
1243: * routines for file systems that don't support volume labels
1244:
1245: */
1246:
1247:
1248:
1249: long
1250:
1251: nowritelabel(dir, name)
1252:
1253: fcookie *dir;
1254:
1255: const char *name;
1256:
1257: {
1258:
1259: return EACCDN;
1260:
1261: }
1262:
1263:
1264:
1265: long
1266:
1267: noreadlabel(dir, name, namelen)
1268:
1269: fcookie *dir;
1270:
1271: char *name;
1272:
1273: int namelen;
1274:
1275: {
1276:
1277: return EFILNF;
1278:
1279: }
1280:
1281:
1282:
1283: /*
1284:
1285: * routines for file systems that don't support links
1286:
1287: */
1288:
1289:
1290:
1291: long
1292:
1293: nosymlink(dir, name, to)
1294:
1295: fcookie *dir;
1296:
1297: const char *name, *to;
1298:
1299: {
1300:
1301: return EINVFN;
1302:
1303: }
1304:
1305:
1306:
1307: long
1308:
1309: noreadlink(dir, buf, buflen)
1310:
1311: fcookie *dir;
1312:
1313: char *buf;
1314:
1315: int buflen;
1316:
1317: {
1318:
1319: return EINVFN;
1320:
1321: }
1322:
1323:
1324:
1325: long
1326:
1327: nohardlink(fromdir, fromname, todir, toname)
1328:
1329: fcookie *fromdir, *todir;
1330:
1331: const char *fromname, *toname;
1332:
1333: {
1334:
1335: return EINVFN;
1336:
1337: }
1338:
1339:
1340:
1341: /* dummy routine for file systems with no Fscntl commands */
1342:
1343:
1344:
1345: long
1346:
1347: nofscntl(dir, name, cmd, arg)
1348:
1349: fcookie *dir;
1350:
1351: const char *name;
1352:
1353: int cmd;
1354:
1355: long arg;
1356:
1357: {
1358:
1359: return EINVFN;
1360:
1361: }
1362:
1363:
1364:
1365: /*
1366:
1367: * Did the disk change? Not on this drive!
1368:
1369: * However, we have to do Getbpb anyways, because someone has decided
1370:
1371: * to force a media change on our (non-existent) drive.
1372:
1373: */
1374:
1375: long
1376:
1377: nodskchng(drv)
1378:
1379: int drv;
1380:
1381: {
1382:
1383: (void)getbpb(drv);
1384:
1385: return 0;
1386:
1387: }
1388:
1389:
1390:
1391: long
1392:
1393: nocreat(dir, name, mode, attrib, fc)
1394:
1395: fcookie *dir, *fc;
1396:
1397: const char *name;
1398:
1399: unsigned mode;
1400:
1401: int attrib;
1402:
1403: {
1404:
1405: return EACCDN;
1406:
1407: }
1408:
1409:
1410:
1411: static DEVDRV *
1412:
1413: bios_getdev(fc, devsp)
1414:
1415: fcookie *fc;
1416:
1417: long *devsp;
1418:
1419: {
1420:
1421: struct bios_file *b;
1422:
1423:
1424:
1425: b = (struct bios_file *)fc->index;
1426:
1427:
1428:
1429: if (b->device && b->device != &fakedev)
1430:
1431: *devsp = (long)b->tty;
1432:
1433: else
1434:
1435: *devsp = b->private;
1436:
1437:
1438:
1439: return b->device; /* return the device driver */
1440:
1441: }
1442:
1443:
1444:
1445: /*
1446:
1447: * NULL device driver
1448:
1449: */
1450:
1451:
1452:
1453: long
1454:
1455: null_open(f)
1456:
1457: FILEPTR *f;
1458:
1459: {
1460:
1461: return 0;
1462:
1463: }
1464:
1465:
1466:
1467: long
1468:
1469: null_write(f, buf, bytes)
1470:
1471: FILEPTR *f; const char *buf; long bytes;
1472:
1473: {
1474:
1475: return bytes;
1476:
1477: }
1478:
1479:
1480:
1481: long
1482:
1483: null_read(f, buf, bytes)
1484:
1485: FILEPTR *f; char *buf; long bytes;
1486:
1487: {
1488:
1489: return 0;
1490:
1491: }
1492:
1493:
1494:
1495: long
1496:
1497: null_lseek(f, where, whence)
1498:
1499: FILEPTR *f; long where; int whence;
1500:
1501: {
1502:
1503: return (where == 0) ? 0 : ERANGE;
1504:
1505: }
1506:
1507:
1508:
1509: long
1510:
1511: null_ioctl(f, mode, buf)
1512:
1513: FILEPTR *f; int mode; void *buf;
1514:
1515: {
1516:
1517: if (mode == FIONREAD) {
1518:
1519: *((long *)buf) = 0;
1520:
1521: }
1522:
1523: else if (mode == FIONWRITE)
1524:
1525: *((long *)buf) = 1;
1526:
1527: else
1528:
1529: return EINVFN;
1530:
1531: return 0;
1532:
1533: }
1534:
1535:
1536:
1537: long
1538:
1539: null_datime(f, timeptr, rwflag)
1540:
1541: FILEPTR *f;
1542:
1543: short *timeptr;
1544:
1545: int rwflag;
1546:
1547: {
1548:
1549: if (rwflag)
1550:
1551: return EACCDN;
1552:
1553: *timeptr++ = timestamp;
1554:
1555: *timeptr = datestamp;
1556:
1557: return 0;
1558:
1559: }
1560:
1561:
1562:
1563: long
1564:
1565: null_close(f, pid)
1566:
1567: FILEPTR *f;
1568:
1569: int pid;
1570:
1571: {
1572:
1573: return 0;
1574:
1575: }
1576:
1577:
1578:
1579: long
1580:
1581: null_select(f, p, mode)
1582:
1583: FILEPTR *f; long p;
1584:
1585: int mode;
1586:
1587: {
1588:
1589: return 1; /* we're always ready to read/write */
1590:
1591: }
1592:
1593:
1594:
1595: void
1596:
1597: null_unselect(f, p, mode)
1598:
1599: FILEPTR *f;
1600:
1601: long p;
1602:
1603: int mode;
1604:
1605: {
1606:
1607: /* nothing to do */
1608:
1609: }
1610:
1611:
1612:
1613: /*
1614:
1615: * BIOS terminal device driver
1616:
1617: */
1618:
1619:
1620:
1621: static long
1622:
1623: bios_topen(f)
1624:
1625: FILEPTR *f;
1626:
1627: {
1628:
1629: f->flags |= O_TTY;
1630:
1631: return 0;
1632:
1633: }
1634:
1635:
1636:
1637: /*
1638:
1639: * Note: when a BIOS device is a terminal (i.e. has the O_TTY flag
1640:
1641: * set), bios_read and bios_write will only ever be called indirectly, via
1642:
1643: * tty_read and tty_write. That's why we can afford to play a bit fast and
1644:
1645: * loose with the pointers ("buf" is really going to point to a long) and
1646:
1647: * why we know that "bytes" is divisible by 4.
1648:
1649: */
1650:
1651:
1652:
1653: static long
1654:
1655: bios_twrite(f, buf, bytes)
1656:
1657: FILEPTR *f; const char *buf; long bytes;
1658:
1659: {
1660:
1661: long *r;
1662:
1663: long ret = 0;
1664:
1665: int bdev = f->fc.aux;
1666:
1667:
1668:
1669: r = (long *)buf;
1670:
1671: while (bytes > 0) {
1672:
1673: if ( (f->flags & O_NDELAY) && !bcostat(bdev) )
1674:
1675: break;
1676:
1677:
1678:
1679: if (bconout(bdev, (int)*r) == 0)
1680:
1681: break;
1682:
1683:
1684:
1685: r++; bytes -= 4; ret+= 4;
1686:
1687: }
1688:
1689: (void)checkkeys();
1690:
1691: return ret;
1692:
1693: }
1694:
1695:
1696:
1697: static long
1698:
1699: bios_tread(f, buf, bytes)
1700:
1701: FILEPTR *f; char *buf; long bytes;
1702:
1703: {
1704:
1705: long *r, ret = 0;
1706:
1707: int bdev = f->fc.aux;
1708:
1709:
1710:
1711: r = (long *)buf;
1712:
1713:
1714:
1715: while (bytes > 0) {
1716:
1717: if ( (f->flags & O_NDELAY) && !bconstat(bdev) )
1718:
1719: break;
1720:
1721: *r++ = bconin(bdev) & 0x7fffffff;
1722:
1723: bytes -= 4; ret += 4;
1724:
1725: }
1726:
1727: return ret;
1728:
1729: }
1730:
1731:
1732:
1733: /*
1734:
1735: * read/write routines for BIOS devices that aren't terminals (like the
1736:
1737: * printer & IKBD devices)
1738:
1739: */
1740:
1741:
1742:
1743: static long
1744:
1745: bios_nwrite(f, buf, bytes)
1746:
1747: FILEPTR *f; const char *buf; long bytes;
1748:
1749: {
1750:
1751: long ret = 0;
1752:
1753: int bdev = f->fc.aux;
1754:
1755: int c;
1756:
1757:
1758:
1759: while (bytes > 0) {
1760:
1761: if ( (f->flags & O_NDELAY) && !bcostat(bdev) )
1762:
1763: break;
1764:
1765:
1766:
1767: c = *buf++ & 0x00ff;
1768:
1769:
1770:
1771: if (bconout(bdev, c) == 0)
1772:
1773: break;
1774:
1775:
1776:
1777: bytes--; ret++;
1778:
1779: }
1780:
1781: return ret;
1782:
1783: }
1784:
1785:
1786:
1787: static long
1788:
1789: bios_nread(f, buf, bytes)
1790:
1791: FILEPTR *f; char *buf; long bytes;
1792:
1793: {
1794:
1795: long ret = 0;
1796:
1797: int bdev = f->fc.aux;
1798:
1799:
1800:
1801: while (bytes > 0) {
1802:
1803: if ( (f->flags & O_NDELAY) && !bconstat(bdev) )
1804:
1805: break;
1806:
1807: *buf++ = bconin(bdev) & 0xff;
1808:
1809: bytes--; ret++;
1810:
1811: }
1812:
1813: return ret;
1814:
1815: }
1816:
1817:
1818:
1819: /*
1820:
1821: * BIOS terminal seek code -- this has to match the documented
1822:
1823: * way to do isatty()
1824:
1825: */
1826:
1827:
1828:
1829: static long
1830:
1831: bios_tseek(f, where, whence)
1832:
1833: FILEPTR *f;
1834:
1835: long where;
1836:
1837: int whence;
1838:
1839: {
1840:
1841: /* terminals always are at position 0 */
1842:
1843: return 0;
1844:
1845: }
1846:
1847:
1848:
1849: #define MAXBAUD 16
1850:
1851:
1852:
1853: static long baudmap[MAXBAUD] = {
1854:
1855: 19200L, 9600L, 4800L, 3600L, 2400L, 2000L, 1800L, 1200L,
1856:
1857: 600L, 300L, 200L, 150L, 134L, 110L, 75L, 50L
1858:
1859: };
1860:
1861:
1862:
1863: static long
1864:
1865: bios_ioctl(f, mode, buf)
1866:
1867: FILEPTR *f; int mode; void *buf;
1868:
1869: {
1870:
1871: long *r = (long *)buf;
1872:
1873: struct winsize *ws;
1874:
1875: char *aline;
1876:
1877: short dev;
1878:
1879: int i;
1880:
1881:
1882:
1883: if (mode == FIONREAD) {
1884:
1885: if (bconstat(f->fc.aux))
1886:
1887: *r = 1;
1888:
1889: else
1890:
1891: *r = 0;
1892:
1893: }
1894:
1895: else if (mode == FIONWRITE) {
1896:
1897: if (bcostat(f->fc.aux))
1898:
1899: *r = 1;
1900:
1901: else
1902:
1903: *r = 0;
1904:
1905: }
1906:
1907: else if (mode == TIOCFLUSH) {
1908:
1909: /* BUG: this should flush the input/output buffers */
1910:
1911: return 0;
1912:
1913: }
1914:
1915: else if (mode == TIOCGWINSZ && f->fc.aux == 2) {
1916:
1917: aline = lineA0();
1918:
1919: ws = (struct winsize *)buf;
1920:
1921: ws->ws_row = *((short *)(aline - 42)) + 1;
1922:
1923: ws->ws_col = *((short *)(aline - 44)) + 1;
1924:
1925: } else if (mode == TIOCIBAUD || mode == TIOCOBAUD) {
1926:
1927: long oldbaud, newbaud;
1928:
1929: dev = f->fc.aux;
1930:
1931:
1932:
1933: newbaud = *r;
1934:
1935: if (dev == 1 || dev >= 6) {
1936:
1937: if (has_bconmap)
1938:
1939: mapin((dev == 1) ? curproc->bconmap : dev);
1940:
1941: i = rsconf(-2, -1, -1, -1, -1, -1);
1942:
1943: if (i < 0 || i >= MAXBAUD)
1944:
1945: oldbaud = -1L;
1946:
1947: else
1948:
1949: oldbaud = baudmap[i];
1950:
1951: *r = oldbaud;
1952:
1953: if (newbaud > 0) {
1954:
1955: for (i = 0; i < MAXBAUD; i++) {
1956:
1957: if (baudmap[i] == newbaud) {
1958:
1959: rsconf(i, -1, -1, -1, -1, -1);
1960:
1961: return 0;
1962:
1963: }
1964:
1965: }
1966:
1967: return ERANGE;
1968:
1969: } else if (newbaud == 0L) {
1970:
1971: /* drop DTR: works only on modem1 */
1972:
1973: if (dev == 1 || dev == 6) {
1974:
1975: Ongibit(0x10);
1976:
1977: nap(30);
1978:
1979: Offgibit(0xef);
1980:
1981: }
1982:
1983: }
1984:
1985: return 0;
1986:
1987: } else if (dev == 2 || dev == 5) {
1988:
1989: /* screen: assume 9600 baud */
1990:
1991: oldbaud = 9600L;
1992:
1993: } else if (dev == 3) {
1994:
1995: /* midi */
1996:
1997: oldbaud = 31250L;
1998:
1999: } else {
2000:
2001: oldbaud = -1L; /* unknown speed */
2002:
2003: }
2004:
2005: *r = oldbaud;
2006:
2007: if (newbaud > 0 && newbaud != oldbaud)
2008:
2009: return ERANGE;
2010:
2011: return 0;
2012:
2013: } else if (mode == TIOCCBRK || mode == TIOCSBRK) {
2014:
2015: unsigned long bits;
2016:
2017:
2018:
2019: dev = f->fc.aux;
2020:
2021: if (dev == 1 || dev >= 6) {
2022:
2023: if (has_bconmap)
2024:
2025: mapin((dev == 1) ? curproc->bconmap : dev);
2026:
2027: } else {
2028:
2029: return EINVFN;
2030:
2031: }
2032:
2033: bits = rsconf(-1, -1, -1, -1, -1, -1); /* get settings */
2034:
2035: bits = (bits >> 8) & 0x0ff; /* isolate TSR byte */
2036:
2037: if (mode == TIOCCBRK)
2038:
2039: bits &= ~8;
2040:
2041: else
2042:
2043: bits |= 8;
2044:
2045: (void)rsconf(-1, -1, -1, -1, (int)bits, -1);
2046:
2047: } else if (mode == TIOCGFLAGS || mode == TIOCSFLAGS) {
2048:
2049: unsigned short oflags, flags;
2050:
2051: unsigned long bits;
2052:
2053: unsigned char ucr;
2054:
2055: short flow;
2056:
2057:
2058:
2059: dev = f->fc.aux;
2060:
2061: if (dev == 1 || dev >= 6) {
2062:
2063: oflags = ((struct tty *)f->devinfo)->sg.sg_flags;
2064:
2065: oflags &= (T_TANDEM|T_RTSCTS);
2066:
2067: if (has_bconmap)
2068:
2069: mapin((dev == 1) ? curproc->bconmap : dev);
2070:
2071: bits = rsconf(-1, -1, -1, -1, -1, -1); /* get settings */
2072:
2073: ucr = (bits >> 24L) & 0x0ff; /* isolate UCR byte */
2074:
2075: oflags |= (ucr >> 3) & (TF_STOPBITS|TF_CHARBITS);
2076:
2077: if (ucr & 0x4) { /* parity on? */
2078:
2079: oflags |= (ucr & 0x2) ? T_EVENP : T_ODDP;
2080:
2081: }
2082:
2083: if (mode == TIOCSFLAGS) {
2084:
2085: flags = (*(unsigned short *)buf);
2086:
2087: if (flags & T_EVENP) {
2088:
2089: ucr |= 0x6;
2090:
2091: } else if (flags & T_ODDP) {
2092:
2093: ucr &= ~2;
2094:
2095: ucr |= 0x4;
2096:
2097: } else {
2098:
2099: ucr &= ~6;
2100:
2101: }
2102:
2103: if (flags & TF_STOPBITS) {
2104:
2105: ucr &= ~(0x18);
2106:
2107: ucr |= (flags & TF_STOPBITS) << 3;
2108:
2109: }
2110:
2111: ucr &= ~(0x60);
2112:
2113: ucr |= (flags & TF_CHARBITS) << 3;
2114:
2115: flow = (flags & (T_RTSCTS|T_TANDEM)) >> 12L;
2116:
2117: rsconf(-1, flow, ucr, -1, -1, -1);
2118:
2119: } else {
2120:
2121: *((unsigned short *)buf) = oflags;
2122:
2123: }
2124:
2125: } else {
2126:
2127: return EINVFN;
2128:
2129: }
2130:
2131:
2132:
2133: } else {
2134:
2135: /* Fcntl will automatically call tty_ioctl to handle
2136:
2137: * terminal calls that we didn't deal with
2138:
2139: */
2140:
2141: return EINVFN;
2142:
2143: }
2144:
2145: return 0;
2146:
2147: }
2148:
2149:
2150:
2151: static long
2152:
2153: bios_select(f, p, mode)
2154:
2155: FILEPTR *f; long p; int mode;
2156:
2157: {
2158:
2159: struct tty *tty = (struct tty *)f->devinfo;
2160:
2161: int dev = f->fc.aux;
2162:
2163:
2164:
2165: if (mode == O_RDONLY) {
2166:
2167: if (bconstat(dev)) {
2168:
2169: TRACE("bios_select: data present for device %d", dev);
2170:
2171: return 1;
2172:
2173: }
2174:
2175: if (tty) {
2176:
2177: /* avoid collisions with other processes */
2178:
2179: if (!tty->rsel)
2180:
2181: tty->rsel = p;
2182:
2183: }
2184:
2185: return 0;
2186:
2187: } else if (mode == O_WRONLY) {
2188:
2189: if (bcostat(dev)) {
2190:
2191: TRACE("bios_select: ready to output on %d", dev);
2192:
2193: return 1;
2194:
2195: }
2196:
2197: if (tty) {
2198:
2199: if (!tty->wsel)
2200:
2201: tty->wsel = p;
2202:
2203: }
2204:
2205: return 0;
2206:
2207: }
2208:
2209: /* default -- we don't know this mode, return 0 */
2210:
2211: return 0;
2212:
2213: }
2214:
2215:
2216:
2217: static void
2218:
2219: bios_unselect(f, p, mode)
2220:
2221: FILEPTR *f;
2222:
2223: long p;
2224:
2225: int mode;
2226:
2227: {
2228:
2229: struct tty *tty = (struct tty *)f->devinfo;
2230:
2231:
2232:
2233: if (tty) {
2234:
2235: if (mode == O_RDONLY && tty->rsel == p)
2236:
2237: tty->rsel = 0;
2238:
2239: else if (mode == O_WRONLY && tty->wsel == p)
2240:
2241: tty->wsel = 0;
2242:
2243: }
2244:
2245: }
2246:
2247:
2248:
2249: /*
2250:
2251: * mouse device driver
2252:
2253: */
2254:
2255:
2256:
2257: #define MOUSESIZ 128*3
2258:
2259: static unsigned char mousebuf[MOUSESIZ];
2260:
2261: static int mousehead, mousetail;
2262:
2263:
2264:
2265: long mousersel; /* is someone calling select() on the mouse? */
2266:
2267:
2268:
2269: char mshift; /* shift key status; set by checkkeys() in bios.c */
2270:
2271: short *gcurx = 0,
2272:
2273: *gcury = 0; /* mouse pos. variables; used by big screen emulators */
2274:
2275:
2276:
2277: void
2278:
2279: mouse_handler(buf)
2280:
2281: const char *buf; /* must be a *signed* character */
2282:
2283: {
2284:
2285: unsigned char *mbuf, buttons;
2286:
2287: int newmtail;
2288:
2289: short dx, dy;
2290:
2291:
2292:
2293: /* the Sun mouse driver has 0=down, 1=up, while the atari hardware gives
2294:
2295: us the reverse. also, we have the "middle" button and the "left"
2296:
2297: button reversed; so we use this table to convert (and also to add the
2298:
2299: 0x80 to indicate a mouse packet)
2300:
2301: */
2302:
2303: static int _cnvrt[8] = {
2304:
2305: 0x87, 0x86, 0x83, 0x82, 0x85, 0x84, 0x81, 0x80
2306:
2307: };
2308:
2309:
2310:
2311: mbuf = &mousebuf[mousetail];
2312:
2313: newmtail = mousetail + 3;
2314:
2315: if (newmtail >= MOUSESIZ)
2316:
2317: newmtail = 0;
2318:
2319: if (newmtail == mousehead)
2320:
2321: return; /* buffer full */
2322:
2323:
2324:
2325: buttons = *buf++ & 0x7; /* convert to SUN format */
2326:
2327: if (mshift & 0x3) { /* a shift key held down? */
2328:
2329: /* if so, convert shift+button to a "middle" button */
2330:
2331: if (buttons == 0x1 || buttons == 0x2)
2332:
2333: buttons = 0x4;
2334:
2335: else if (buttons == 0x3)
2336:
2337: buttons = 0x7;
2338:
2339: }
2340:
2341: *mbuf++ = _cnvrt[buttons]; /* convert to Sun format */
2342:
2343: dx = *buf++;
2344:
2345: *mbuf++ = dx; /* copy X delta */
2346:
2347: dy = *buf++;
2348:
2349: *mbuf++ = -dy; /* invert Y delta for Sun format */
2350:
2351: mousetail = newmtail;
2352:
2353: *gcurx += dx; /* update line A variables */
2354:
2355: *gcury += dy;
2356:
2357: /*
2358:
2359: * if someone has called select() waiting for mouse input, wake them
2360:
2361: * up
2362:
2363: */
2364:
2365: if (mousersel) {
2366:
2367: wakeselect(mousersel);
2368:
2369: }
2370:
2371: }
2372:
2373:
2374:
2375: extern void newmvec(); /* in intr.s */
2376:
2377: static long oldvec = 0;
2378:
2379:
2380:
2381: static long
2382:
2383: mouse_open(f)
2384:
2385: FILEPTR *f;
2386:
2387: {
2388:
2389: char *aline;
2390:
2391:
2392:
2393: static char parameters[] = {
2394:
2395: 0, /* Y=0 in lower corner */
2396:
2397: 0, /* normal button handling */
2398:
2399: 1, 1 /* X, Y scaling factors */
2400:
2401: };
2402:
2403:
2404:
2405: if (oldvec) /* mouse in use */
2406:
2407: return EACCDN;
2408:
2409:
2410:
2411: /* initialize pointers to line A variables */
2412:
2413: if (!gcurx) {
2414:
2415: aline = lineA0();
2416:
2417: if (aline == 0) { /* should never happen */
2418:
2419: ALERT("unable to read line A variables");
2420:
2421: return -1;
2422:
2423: }
2424:
2425: gcurx = (short *)(aline - 0x25a);
2426:
2427: gcury = (short *)(aline - 0x258);
2428:
2429: *gcurx = *gcury = 32; /* magic number -- what MGR uses */
2430:
2431: }
2432:
2433:
2434:
2435: oldvec = syskey->mousevec;
2436:
2437: Initmous(1, parameters, newmvec);
2438:
2439: mousehead = mousetail = 0;
2440:
2441: return 0;
2442:
2443: }
2444:
2445:
2446:
2447: static long
2448:
2449: mouse_close(f, pid)
2450:
2451: FILEPTR *f;
2452:
2453: int pid;
2454:
2455: {
2456:
2457: static char parameters[] = {
2458:
2459: 0, /* Y=0 in lower corner */
2460:
2461: 0, /* normal button handling */
2462:
2463: 1, 1 /* X, Y scaling factors */
2464:
2465: };
2466:
2467:
2468:
2469: if (!f) return EIHNDL;
2470:
2471: if (f->links <= 0) {
2472:
2473: if (!oldvec) {
2474:
2475: DEBUG("Mouse not open!!");
2476:
2477: return -1;
2478:
2479: }
2480:
2481: Initmous(1, parameters, (void *)oldvec); /* gratuitous (void *) for Lattice */
2482:
2483: oldvec = 0;
2484:
2485: }
2486:
2487: return 0;
2488:
2489: }
2490:
2491:
2492:
2493: static long
2494:
2495: mouse_read(f, buf, nbytes)
2496:
2497: FILEPTR *f;
2498:
2499: char *buf;
2500:
2501: long nbytes;
2502:
2503: {
2504:
2505: long count = 0;
2506:
2507: int mhead;
2508:
2509: unsigned char *foo;
2510:
2511:
2512:
2513: mhead = mousehead;
2514:
2515: foo = &mousebuf[mhead];
2516:
2517:
2518:
2519: if (mhead == mousetail) {
2520:
2521: if (f->flags & O_NDELAY)
2522:
2523: return 0;
2524:
2525: do {
2526:
2527: TRACE("yielding in mouse_read");
2528:
2529: yield();
2530:
2531: } while (mhead == mousetail);
2532:
2533: }
2534:
2535:
2536:
2537: while ( (mhead != mousetail) && (nbytes > 0)) {
2538:
2539: *buf++ = *foo++;
2540:
2541: mhead++;
2542:
2543: if (mhead >= MOUSESIZ) {
2544:
2545: mhead = 0;
2546:
2547: foo = mousebuf;
2548:
2549: }
2550:
2551: count++;
2552:
2553: --nbytes;
2554:
2555: }
2556:
2557: mousehead = mhead;
2558:
2559: return count;
2560:
2561: }
2562:
2563:
2564:
2565: static long
2566:
2567: mouse_ioctl(f, mode, buf)
2568:
2569: FILEPTR *f;
2570:
2571: int mode;
2572:
2573: void *buf;
2574:
2575: {
2576:
2577: long r;
2578:
2579:
2580:
2581: if (mode == FIONREAD) {
2582:
2583: r = mousetail - mousehead;
2584:
2585: if (r < 0) r += MOUSESIZ;
2586:
2587: *((long *)buf) = r;
2588:
2589: }
2590:
2591: else
2592:
2593: return EINVFN;
2594:
2595: return 0;
2596:
2597: }
2598:
2599:
2600:
2601: static long
2602:
2603: mouse_select(f, p, mode)
2604:
2605: FILEPTR *f;
2606:
2607: long p;
2608:
2609: int mode;
2610:
2611: {
2612:
2613: if (mode != O_RDONLY)
2614:
2615: return 1; /* we can always take output :-) */
2616:
2617:
2618:
2619: if (mousetail - mousehead)
2620:
2621: return 1; /* input waiting already */
2622:
2623:
2624:
2625: if (!mousersel)
2626:
2627: mousersel = p;
2628:
2629: return 0;
2630:
2631: }
2632:
2633:
2634:
2635: static void
2636:
2637: mouse_unselect(f, p, mode)
2638:
2639: FILEPTR *f;
2640:
2641: long p;
2642:
2643: int mode;
2644:
2645: {
2646:
2647: if (mode == O_RDONLY && mousersel == p)
2648:
2649: mousersel = 0;
2650:
2651: }
2652:
2653:
2654:
2655:
2656:
2657: /*
2658:
2659: * UTILITY ROUTINE called by Bconmap() in xbios.c:
2660:
2661: * this sets handle -1 of process p to a file handle
2662:
2663: * that has BIOS device "dev". Returns 0 on failure,
2664:
2665: * non-zero on success.
2666:
2667: */
2668:
2669:
2670:
2671: int
2672:
2673: set_auxhandle(p, dev)
2674:
2675: PROC *p;
2676:
2677: int dev;
2678:
2679: {
2680:
2681: FILEPTR *f;
2682:
2683: struct bios_file *b;
2684:
2685:
2686:
2687: f = new_fileptr();
2688:
2689: if (f) {
2690:
2691: f->links = 1;
2692:
2693: f->flags = O_RDWR;
2694:
2695: f->pos = 0;
2696:
2697: f->devinfo = 0;
2698:
2699: f->fc.fs = &bios_filesys;
2700:
2701: f->fc.aux = dev;
2702:
2703: f->fc.dev = BIOSDRV;
2704:
2705: for (b = broot; b; b = b->next) {
2706:
2707: if (b->private == dev &&
2708:
2709: (b->device == &bios_tdevice ||
2710:
2711: b->device == &bios_ndevice)) {
2712:
2713: f->fc.index = (long)b;
2714:
2715: f->dev = b->device;
2716:
2717: if (b->device != &fakedev)
2718:
2719: f->devinfo = (long)b->tty;
2720:
2721: goto found_device;
2722:
2723: }
2724:
2725: }
2726:
2727: f->fc.index = 0;
2728:
2729: f->dev = &bios_ndevice;
2730:
2731: found_device:
2732:
2733: if ((*f->dev->open)(f) < 0) {
2734:
2735: f->links = 0;
2736:
2737: dispose_fileptr(f);
2738:
2739: return 0;
2740:
2741: }
2742:
2743: } else {
2744:
2745: /* no memory! use the fake FILEPTR we
2746:
2747: * set up in biosfs_init
2748:
2749: */
2750:
2751: f = defaultaux;
2752:
2753: f->links++;
2754:
2755: }
2756:
2757:
2758:
2759: (void)do_pclose(p, p->aux);
2760:
2761: p->aux = f;
2762:
2763:
2764:
2765: return 1;
2766:
2767: }
2768:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.