4 * Copyright 1999 Ove Kåven
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/winbase16.h"
27 #include "wine/debug.h"
39 BYTE size; /* length of header + data */
40 BYTE unit; /* unit (block devices only) */
48 BYTE media; /* media descriptor from BPB */
50 WORD count; /* byte/sector count */
51 WORD sector; /* starting sector (block devices) */
52 DWORD volume; /* volume ID (block devices) */
62 #define CON_BUFFER 128
64 enum strategy { SYSTEM_STRATEGY_NUL, SYSTEM_STRATEGY_CON, NB_SYSTEM_STRATEGIES };
66 static void *strategy_data[NB_SYSTEM_STRATEGIES];
68 #define NONEXT ((DWORD)-1)
70 #define ATTR_STDIN 0x0001
71 #define ATTR_STDOUT 0x0002
72 #define ATTR_NUL 0x0004
73 #define ATTR_CLOCK 0x0008
74 #define ATTR_FASTCON 0x0010
75 #define ATTR_RAW 0x0020
76 #define ATTR_NOTEOF 0x0040
77 #define ATTR_DEVICE 0x0080
78 #define ATTR_REMOVABLE 0x0800
79 #define ATTR_NONIBM 0x2000 /* block devices */
80 #define ATTR_UNTILBUSY 0x2000 /* char devices */
81 #define ATTR_IOCTL 0x4000
82 #define ATTR_CHAR 0x8000
85 #define CMD_MEDIACHECK 1 /* block devices */
86 #define CMD_BUILDBPB 2 /* block devices */
88 #define CMD_INPUT 4 /* read data */
89 #define CMD_SAFEINPUT 5 /* "non-destructive input no wait", char devices */
90 #define CMD_INSTATUS 6 /* char devices */
91 #define CMD_INFLUSH 7 /* char devices */
92 #define CMD_OUTPUT 8 /* write data */
93 #define CMD_SAFEOUTPUT 9 /* write data with verify */
94 #define CMD_OUTSTATUS 10 /* char devices */
95 #define CMD_OUTFLUSH 11 /* char devices */
96 #define CMD_OUTIOCTL 12
97 #define CMD_DEVOPEN 13
98 #define CMD_DEVCLOSE 14
99 #define CMD_REMOVABLE 15 /* block devices */
100 #define CMD_UNTILBUSY 16 /* output until busy */
102 #define STAT_MASK 0x00FF
103 #define STAT_DONE 0x0100
104 #define STAT_BUSY 0x0200
105 #define STAT_ERROR 0x8000
111 static void WINAPI nul_strategy(CONTEXT86*ctx);
112 static void WINAPI nul_interrupt(CONTEXT86*ctx);
113 static void WINAPI con_strategy(CONTEXT86*ctx);
114 static void WINAPI con_interrupt(CONTEXT86*ctx);
125 static WINEDEV devs[] =
128 ATTR_CHAR|ATTR_NUL|ATTR_DEVICE,
129 nul_strategy, nul_interrupt },
132 ATTR_CHAR|ATTR_STDIN|ATTR_STDOUT|ATTR_FASTCON|ATTR_NOTEOF|ATTR_DEVICE,
133 con_strategy, con_interrupt }
136 #define NR_DEVS (sizeof(devs)/sizeof(WINEDEV))
138 /* DOS data segment */
142 DOS_DEVICE_HEADER dev[NR_DEVS-1];
143 WINEDEV_THUNK thunk[NR_DEVS];
145 BYTE buffer[CON_BUFFER];
149 #define DOS_DATASEG_OFF(xxx) FIELD_OFFSET(DOS_DATASEG, xxx)
151 struct _DOS_LISTOFLISTS * DOSMEM_LOL()
153 return (struct _DOS_LISTOFLISTS *)DOSMEM_MapRealToLinear
154 (MAKESEGPTR(HIWORD(DOS_LOLSeg),0));
158 /* the device implementations */
159 static void do_lret(CONTEXT86*ctx)
161 WORD *stack = CTX_SEG_OFF_TO_LIN(ctx, ctx->SegSs, ctx->Esp);
163 ctx->Eip = *(stack++);
164 ctx->SegCs = *(stack++);
165 ctx->Esp += 2*sizeof(WORD);
168 static void do_strategy(CONTEXT86*ctx, int id, int extra)
170 REQUEST_HEADER *hdr = CTX_SEG_OFF_TO_LIN(ctx, ctx->SegEs, ctx->Ebx);
171 void **hdr_ptr = strategy_data[id];
174 hdr_ptr = calloc(1,sizeof(void *)+extra);
175 strategy_data[id] = hdr_ptr;
181 static REQUEST_HEADER * get_hdr(int id, void**extra)
183 void **hdr_ptr = strategy_data[id];
185 *extra = hdr_ptr ? (void*)(hdr_ptr+1) : (void *)NULL;
186 return hdr_ptr ? *hdr_ptr : (void *)NULL;
189 static void WINAPI nul_strategy(CONTEXT86*ctx)
191 do_strategy(ctx, SYSTEM_STRATEGY_NUL, 0);
194 static void WINAPI nul_interrupt(CONTEXT86*ctx)
196 REQUEST_HEADER *hdr = get_hdr(SYSTEM_STRATEGY_NUL, NULL);
197 /* eat everything and recycle nothing */
198 switch (hdr->command) {
200 ((REQ_IO*)hdr)->count = 0;
201 hdr->status = STAT_DONE;
204 hdr->status = STAT_DONE|STAT_BUSY;
207 hdr->status = STAT_DONE;
212 static void WINAPI con_strategy(CONTEXT86*ctx)
214 do_strategy(ctx, SYSTEM_STRATEGY_CON, sizeof(int));
217 static void WINAPI con_interrupt(CONTEXT86*ctx)
220 REQUEST_HEADER *hdr = get_hdr(SYSTEM_STRATEGY_CON,(void **)&scan);
221 BIOSDATA *bios = DOSMEM_BiosData();
222 WORD CurOfs = bios->NextKbdCharPtr;
223 DOS_LISTOFLISTS *lol = DOSMEM_LOL();
224 DOS_DATASEG *dataseg = (DOS_DATASEG *)lol;
225 BYTE *linebuffer = dataseg->buffer;
226 BYTE *curbuffer = (lol->offs_unread_CON) ?
227 (((BYTE*)dataseg) + lol->offs_unread_CON) : (BYTE*)NULL;
228 DOS_DEVICE_HEADER *con = dataseg->dev;
230 switch (hdr->command) {
233 REQ_IO *io = (REQ_IO *)hdr;
234 WORD count = io->count, len = 0;
235 BYTE *buffer = CTX_SEG_OFF_TO_LIN(ctx,
236 SELECTOROF(io->buffer),
237 (DWORD)OFFSETOF(io->buffer));
239 hdr->status = STAT_BUSY;
240 /* first, check whether we already have data in line buffer */
242 /* yep, copy as much as we can */
244 while ((len<count) && (data != '\r')) {
246 buffer[len++] = data;
249 /* line buffer emptied */
250 lol->offs_unread_CON = 0;
252 /* if we're not in raw mode, call it a day */
253 if (!(con->attr & ATTR_RAW)) {
254 hdr->status = STAT_DONE;
259 /* still some data left */
260 lol->offs_unread_CON = curbuffer - (BYTE*)lol;
261 /* but buffer was filled, we're done */
262 hdr->status = STAT_DONE;
268 /* if we're in raw mode, we just need to fill the buffer */
269 if (con->attr & ATTR_RAW) {
273 /* do we have a waiting scancode? */
275 /* yes, store scancode in buffer */
276 buffer[len++] = *scan;
278 if (len==count) break;
281 /* check for new keyboard input */
282 while (CurOfs == bios->FirstKbdCharPtr) {
283 /* no input available yet, so wait... */
286 /* read from keyboard queue (call int16?) */
287 data = ((WORD*)bios)[CurOfs];
289 if (CurOfs >= bios->KbdBufferEnd) CurOfs = bios->KbdBufferStart;
290 bios->NextKbdCharPtr = CurOfs;
291 /* if it's an extended key, save scancode */
292 if (LOBYTE(data) == 0) *scan = HIBYTE(data);
293 /* store ASCII char in buffer */
294 buffer[len++] = LOBYTE(data);
297 /* we're not in raw mode, so we need to do line input... */
300 /* check for new keyboard input */
301 while (CurOfs == bios->FirstKbdCharPtr) {
302 /* no input available yet, so wait... */
305 /* read from keyboard queue (call int16?) */
306 data = ((WORD*)bios)[CurOfs];
308 if (CurOfs >= bios->KbdBufferEnd) CurOfs = bios->KbdBufferStart;
309 bios->NextKbdCharPtr = CurOfs;
311 if (LOBYTE(data) == '\r') {
312 /* it's the return key, we're done */
313 linebuffer[len++] = LOBYTE(data);
316 else if (LOBYTE(data) >= ' ') {
318 if ((len+1)<CON_BUFFER) {
319 linebuffer[len] = LOBYTE(data);
320 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), &linebuffer[len++], 1, NULL, NULL);
322 /* else beep, but I don't like noise */
324 else switch (LOBYTE(data)) {
328 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "\b \b", 3, NULL, NULL);
334 /* save rest of line for later */
335 lol->offs_unread_CON = linebuffer - (BYTE*)lol + count;
338 memcpy(buffer, linebuffer, len);
340 hdr->status = STAT_DONE;
346 /* some line input waiting */
347 hdr->status = STAT_DONE;
348 ((REQ_SAFEINPUT*)hdr)->data = *curbuffer;
350 else if (con->attr & ATTR_RAW) {
351 if (CurOfs == bios->FirstKbdCharPtr) {
353 hdr->status = STAT_DONE|STAT_BUSY;
355 /* some keyboard input waiting */
356 hdr->status = STAT_DONE;
357 ((REQ_SAFEINPUT*)hdr)->data = ((BYTE*)bios)[CurOfs];
361 hdr->status = STAT_DONE|STAT_BUSY;
367 hdr->status = STAT_DONE;
369 else if (con->attr & ATTR_RAW) {
370 if (CurOfs == bios->FirstKbdCharPtr) {
372 hdr->status = STAT_DONE|STAT_BUSY;
374 /* some keyboard input waiting */
375 hdr->status = STAT_DONE;
379 hdr->status = STAT_DONE|STAT_BUSY;
384 /* flush line and keyboard queue */
385 lol->offs_unread_CON = 0;
386 bios->NextKbdCharPtr = bios->FirstKbdCharPtr;
391 REQ_IO *io = (REQ_IO *)hdr;
392 BYTE *buffer = CTX_SEG_OFF_TO_LIN(ctx,
393 SELECTOROF(io->buffer),
394 (DWORD)OFFSETOF(io->buffer));
396 WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, io->count, &result, NULL);
398 hdr->status = STAT_DONE;
402 hdr->status = STAT_DONE;
407 static void InitListOfLists(DOS_LISTOFLISTS *DOS_LOL)
412 0133:0020 6A 13-33 01 CC 00 33 01 59 00 j.3...3.Y.
413 0133:0030 70 00 00 00 72 02 00 02-6D 00 33 01 00 00 2E 05 p...r...m.3.....
414 0133:0040 00 00 FC 04 00 00 03 08-92 21 11 E0 04 80 C6 0D .........!......
415 0133:0050 CC 0D 4E 55 4C 20 20 20-20 20 00 00 00 00 00 00 ..NUL ......
416 0133:0060 00 4B BA C1 06 14 00 00-00 03 01 00 04 70 CE FF .K...........p..
417 0133:0070 FF 00 00 00 00 00 00 00-00 01 00 00 0D 05 00 00 ................
418 0133:0080 00 FF FF 00 00 00 00 FE-00 00 F8 03 FF 9F 70 02 ..............p.
419 0133:0090 D0 44 C8 FD D4 44 C8 FD-D4 44 C8 FD D0 44 C8 FD .D...D...D...D..
420 0133:00A0 D0 44 C8 FD D0 44 .D...D
422 DOS_LOL->CX_Int21_5e01 = 0x0;
423 DOS_LOL->LRU_count_FCB_cache = 0x0;
424 DOS_LOL->LRU_count_FCB_open = 0x0;
425 DOS_LOL->OEM_func_handler = -1; /* not available */
426 DOS_LOL->INT21_offset = 0x0;
427 DOS_LOL->sharing_retry_count = 3;
428 DOS_LOL->sharing_retry_delay = 1;
429 DOS_LOL->ptr_disk_buf = 0x0;
430 DOS_LOL->offs_unread_CON = 0x0;
431 DOS_LOL->seg_first_MCB = 0x0;
432 DOS_LOL->ptr_first_DPB = 0x0;
433 DOS_LOL->ptr_first_SysFileTable = 0x0;
434 DOS_LOL->ptr_clock_dev_hdr = 0x0;
435 DOS_LOL->ptr_CON_dev_hdr = 0x0;
436 DOS_LOL->max_byte_per_sec = 512;
437 DOS_LOL->ptr_disk_buf_info = 0x0;
438 DOS_LOL->ptr_array_CDS = 0x0;
439 DOS_LOL->ptr_sys_FCB = 0x0;
440 DOS_LOL->nr_protect_FCB = 0x0;
441 DOS_LOL->nr_block_dev = 0x0;
442 DOS_LOL->nr_avail_drive_letters = 26; /* A - Z */
443 DOS_LOL->nr_drives_JOINed = 0x0;
444 DOS_LOL->ptr_spec_prg_names = 0x0;
445 DOS_LOL->ptr_SETVER_prg_list = 0x0; /* no SETVER list */
446 DOS_LOL->DOS_HIGH_A20_func_offs = 0x0;
447 DOS_LOL->PSP_last_exec = 0x0;
448 DOS_LOL->BUFFERS_val = 99; /* maximum: 99 */
449 DOS_LOL->BUFFERS_nr_lookahead = 8; /* maximum: 8 */
450 DOS_LOL->boot_drive = 3; /* C: */
451 DOS_LOL->flag_DWORD_moves = 0x01; /* i386+ */
452 DOS_LOL->size_extended_mem = 0xf000; /* very high value */
455 void DOSDEV_InstallDOSDevices(void)
457 DOS_DATASEG *dataseg;
461 /* allocate DOS data segment or something */
462 DOS_LOLSeg = GlobalDOSAlloc16(sizeof(DOS_DATASEG));
463 seg = HIWORD(DOS_LOLSeg);
464 dataseg = MapSL( MAKESEGPTR(LOWORD(DOS_LOLSeg), 0) );
466 /* initialize the magnificent List Of Lists */
467 InitListOfLists(&dataseg->lol);
469 /* Set up first device (NUL) */
470 dataseg->lol.NUL_dev.next_dev = MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[0]));
471 dataseg->lol.NUL_dev.attr = devs[0].attr;
472 dataseg->lol.NUL_dev.strategy = DOS_DATASEG_OFF(thunk[0].ljmp1);
473 dataseg->lol.NUL_dev.interrupt = DOS_DATASEG_OFF(thunk[0].ljmp2);
474 memcpy(dataseg->lol.NUL_dev.name, devs[0].name, 8);
476 /* Set up the remaining devices */
477 for (n = 1; n < NR_DEVS; n++)
479 dataseg->dev[n-1].next_dev = (n+1) == NR_DEVS ? NONEXT :
480 MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[n]));
481 dataseg->dev[n-1].attr = devs[n].attr;
482 dataseg->dev[n-1].strategy = DOS_DATASEG_OFF(thunk[n].ljmp1);
483 dataseg->dev[n-1].interrupt = DOS_DATASEG_OFF(thunk[n].ljmp2);
484 memcpy(dataseg->dev[n-1].name, devs[n].name, 8);
488 for (n = 0; n < NR_DEVS; n++)
490 dataseg->thunk[n].ljmp1 = LJMP;
491 dataseg->thunk[n].strategy = (RMCBPROC)DPMI_AllocInternalRMCB(devs[n].strategy);
492 dataseg->thunk[n].ljmp2 = LJMP;
493 dataseg->thunk[n].interrupt = (RMCBPROC)DPMI_AllocInternalRMCB(devs[n].interrupt);
496 /* CON is device 1 */
497 dataseg->lol.ptr_CON_dev_hdr = MAKESEGPTR(seg, DOS_DATASEG_OFF(dev[0]));
500 DWORD DOSDEV_Console(void)
502 return DOSMEM_LOL()->ptr_CON_dev_hdr;
505 DWORD DOSDEV_FindCharDevice(char*name)
507 SEGPTR cur_ptr = MAKESEGPTR(HIWORD(DOS_LOLSeg), FIELD_OFFSET(DOS_LISTOFLISTS,NUL_dev));
508 DOS_DEVICE_HEADER *cur = DOSMEM_MapRealToLinear(cur_ptr);
512 /* get first 8 characters */
513 strncpy(dname,name,8);
514 /* if less than 8 characters, pad with spaces */
515 for (cnt=0; cnt<8; cnt++)
516 if (!dname[cnt]) dname[cnt]=' ';
518 /* search for char devices with the right name */
520 ((!(cur->attr & ATTR_CHAR)) ||
521 memcmp(cur->name,dname,8))) {
522 cur_ptr = cur->next_dev;
523 if (cur_ptr == NONEXT) cur=NULL;
524 else cur = DOSMEM_MapRealToLinear(cur_ptr);
529 static void DOSDEV_DoReq(void*req, DWORD dev)
531 REQUEST_HEADER *hdr = (REQUEST_HEADER *)req;
532 DOS_DEVICE_HEADER *dhdr;
536 dhdr = DOSMEM_MapRealToLinear(dev);
537 phdr = ((char*)DOSMEM_LOL()) + DOS_DATASEG_OFF(req);
539 /* copy request to request scratch area */
540 memcpy(phdr, req, hdr->size);
542 /* prepare to call device driver */
543 memset(&ctx, 0, sizeof(ctx));
545 /* ES:BX points to request for strategy routine */
546 ctx.SegEs = HIWORD(DOS_LOLSeg);
547 ctx.Ebx = DOS_DATASEG_OFF(req);
549 /* call strategy routine */
550 ctx.SegCs = SELECTOROF(dev);
551 ctx.Eip = dhdr->strategy;
552 DPMI_CallRMProc(&ctx, 0, 0, 0);
554 /* call interrupt routine */
555 ctx.SegCs = SELECTOROF(dev);
556 ctx.Eip = dhdr->interrupt;
557 DPMI_CallRMProc(&ctx, 0, 0, 0);
559 /* completed, copy request back */
560 memcpy(req, phdr, hdr->size);
562 if (hdr->status & STAT_ERROR) {
563 switch (hdr->status & STAT_MASK) {
564 case 0x0F: /* invalid disk change */
565 /* this error seems to fit the bill */
566 SetLastError(ER_NotSameDevice);
569 SetLastError((hdr->status & STAT_MASK) + 0x13);
575 static int DOSDEV_IO(unsigned cmd, DWORD dev, DWORD buf, int buflen)
579 req.hdr.size=sizeof(req);
580 req.hdr.unit=0; /* not dealing with block devices yet */
582 req.hdr.status=STAT_BUSY;
583 req.media=0; /* not dealing with block devices yet */
586 req.sector=0; /* block devices */
587 req.volume=0; /* block devices */
589 DOSDEV_DoReq(&req, dev);
594 int DOSDEV_Peek(DWORD dev, BYTE*data)
598 req.hdr.size=sizeof(req);
599 req.hdr.unit=0; /* not dealing with block devices yet */
600 req.hdr.command=CMD_SAFEINPUT;
601 req.hdr.status=STAT_BUSY;
604 DOSDEV_DoReq(&req, dev);
606 if (req.hdr.status & STAT_BUSY) return 0;
612 int DOSDEV_Read(DWORD dev, DWORD buf, int buflen)
614 return DOSDEV_IO(CMD_INPUT, dev, buf, buflen);
617 int DOSDEV_Write(DWORD dev, DWORD buf, int buflen, int verify)
619 return DOSDEV_IO(verify?CMD_SAFEOUTPUT:CMD_OUTPUT, dev, buf, buflen);
622 int DOSDEV_IoctlRead(DWORD dev, DWORD buf, int buflen)
624 return DOSDEV_IO(CMD_INIOCTL, dev, buf, buflen);
627 int DOSDEV_IoctlWrite(DWORD dev, DWORD buf, int buflen)
629 return DOSDEV_IO(CMD_OUTIOCTL, dev, buf, buflen);