Replace 'All xxx pages' text in common print dialog by simple 'All'.
[wine] / dlls / winedos / int2f.c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3  * DOS interrupt 2fh handler
4  *
5  *  Cdrom - device driver emulation - Audio features.
6  *     Copyright (c) 1998 Petr Tomasek <tomasek@etf.cuni.cz>
7  *     Copyright (c) 1999,2002 Eric Pouech
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include "config.h"
25
26 #include <string.h>
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30 #include "wine/winbase16.h"
31 #include "miscemu.h"
32 #include "wine/debug.h"
33 #include "ntstatus.h"
34 #include "winioctl.h"
35 #include "ntddstor.h"
36 #include "ntddcdrm.h"
37 #include "dosexe.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(int);
40
41 /* base WPROCS.DLL ordinal number for VxDs */
42 #define VXD_BASE 400
43
44 static void do_int2f_16( CONTEXT86 *context );
45 static void MSCDEX_Handler( CONTEXT86 *context );
46
47 /**********************************************************************
48  *          DOSVM_Int2fHandler (WINEDOS16.147)
49  *
50  * Handler for int 2fh (multiplex).
51  */
52 void WINAPI DOSVM_Int2fHandler( CONTEXT86 *context )
53 {
54     TRACE("Subfunction 0x%X\n", AX_reg(context));
55
56     switch(AH_reg(context))
57     {
58     case 0x10:
59         SET_AL( context, 0xff ); /* share is installed */
60         break;
61
62     case 0x11:  /* Network Redirector / IFSFUNC */
63         switch (LOBYTE(context->Eax))
64         {
65         case 0x00:  /* Install check */
66             /* not installed */
67             break;
68         case 0x80:  /* Enhanced services - Install check */
69             /* not installed */
70             break;
71         default:
72            INT_BARF( context, 0x2f );
73             break;
74         }
75         break;
76
77     case 0x12:
78         switch (LOBYTE(context->Eax))
79         {
80         case 0x2e: /* get or set DOS error table address */
81             switch (DL_reg(context))
82             {
83             /* Four tables: even commands are 'get', odd are 'set' */
84             /* DOS 5.0+ ignores "set" commands */
85             case 0x01:
86             case 0x03:
87             case 0x05:
88             case 0x07:
89             case 0x09:
90                 break;
91             /* Instead of having a message table in DOS-space, */
92             /* we can use a special case for MS-DOS to force   */
93             /* the secondary interface.                               */
94             case 0x00:
95             case 0x02:
96             case 0x04:
97             case 0x06:
98                 context->SegEs = 0x0001;
99                 SET_DI( context, 0x0000 );
100                 break;
101             case 0x08:
102                 FIXME("No real-mode handler for errors yet! (bye!)\n");
103                 break;
104             default:
105                 INT_BARF(context, 0x2f);
106             }
107             break;
108         default:
109            INT_BARF(context, 0x2f);
110         }
111         break;
112
113     case 0x15: /* mscdex */
114         MSCDEX_Handler(context);
115         break;
116
117     case 0x16:
118         do_int2f_16( context );
119         break;
120
121     case 0x1a: /* ANSI.SYS / AVATAR.SYS Install Check */
122         /* Not supported yet, do nothing */
123         break;
124
125     case 0x43:
126 #if 1
127        switch (LOBYTE(context->Eax))
128        {
129        case 0x00:   /* XMS v2+ installation check */
130            WARN("XMS is not fully implemented\n");
131            SET_AL( context, 0x80 );
132            break;
133        case 0x10:   /* XMS v2+ get driver address */
134        {
135             context->SegEs = DOSVM_dpmi_segments->xms_seg;
136             SET_BX( context, 0 );
137             break;
138        }
139        default:
140            INT_BARF( context, 0x2f );
141        }
142 #else
143        FIXME("check for XMS (not supported)\n");
144        SET_AL( context, 0x42 ); /* != 0x80 */
145 #endif
146        break;
147
148     case 0x45:
149        switch (LOBYTE(context->Eax))
150        {
151        case 0x00:
152        case 0x01:
153        case 0x02:
154        case 0x03:
155        case 0x04:
156        case 0x05:
157        case 0x06:
158        case 0x07:
159        case 0x08:
160            /* Microsoft Profiler - not installed */
161            break;
162        default:
163             INT_BARF( context, 0x2f );
164        }
165        break;
166
167     case 0x4a:
168         switch(LOBYTE(context->Eax))
169         {
170        case 0x10:  /* smartdrv */
171            break;  /* not installed */
172         case 0x11:  /* dblspace */
173             break;  /* not installed */
174         case 0x12:  /* realtime compression interface */
175             break;  /* not installed */
176         case 0x32:  /* patch IO.SYS (???) */
177             break;  /* we have no IO.SYS, so we can't patch it :-/ */
178         default:
179             INT_BARF( context, 0x2f );
180         }
181         break;
182     case 0x4b:
183        switch(LOBYTE(context->Eax))
184        {
185        case 0x01:
186        case 0x02:
187        case 0x03:
188        case 0x04:
189        case 0x05:
190            FIXME("Task Switcher - not implemented\n");
191            break;
192        default:
193            INT_BARF( context, 0x2f );
194        }
195        break;
196     case 0x56:  /* INTERLNK */
197        switch(LOBYTE(context->Eax))
198        {
199        case 0x01:  /* check if redirected drive */
200            SET_AL( context, 0 ); /* not redirected */
201            break;
202        default:
203            INT_BARF( context, 0x2f );
204        }
205        break;
206     case 0x7a:  /* NOVELL NetWare */
207         switch (LOBYTE(context->Eax))
208         {
209        case 0x0:  /* Low-level Netware installation check AL=0 not installed.*/
210             SET_AL( context, 0 );
211             break;
212         case 0x20:  /* Get VLM Call Address */
213             /* return nothing -> NetWare not installed */
214             break;
215         default:
216            INT_BARF( context, 0x2f );
217             break;
218         }
219         break;
220     case 0xb7:  /* append */
221         SET_AL( context, 0 ); /* not installed */
222         break;
223     case 0xb8:  /* network */
224         switch (LOBYTE(context->Eax))
225         {
226         case 0x00:  /* Install check */
227             /* not installed */
228             break;
229         default:
230            INT_BARF( context, 0x2f );
231             break;
232         }
233         break;
234     case 0xbc:
235         if (AL_reg(context) == 0x00 && BX_reg(context) == 0x3f3f) {
236             /* MVSOUND.SYS - Install check: not installed */
237         } else { 
238             INT_BARF( context, 0x2f );
239         }
240        break;
241     case 0xbd:  /* some Novell network install check ??? */
242         SET_AX( context, 0xa5a5 ); /* pretend to have Novell IPX installed */
243        break;
244     case 0xbf:  /* REDIRIFS.EXE */
245         switch (LOBYTE(context->Eax))
246         {
247         case 0x00:  /* Install check */
248             /* not installed */
249             break;
250         default:
251            INT_BARF( context, 0x2f );
252             break;
253         }
254         break;
255     case 0xd2:
256        switch(LOBYTE(context->Eax))
257        {
258        case 0x01: /* Quarterdeck RPCI - QEMM/QRAM - PCL-838.EXE functions */
259            if(BX_reg(context) == 0x5145 && CX_reg(context) == 0x4D4D
260              && DX_reg(context) == 0x3432)
261                TRACE("Check for QEMM v5.0+ (not installed)\n");
262                break;
263        default:
264            INT_BARF( context, 0x2f );
265            break;
266        }
267        break;
268     case 0xd7:  /* Banyan Vines */
269         switch (LOBYTE(context->Eax))
270         {
271         case 0x01:  /* Install check - Get Int Number */
272             /* not installed */
273             break;
274         default:
275            INT_BARF( context, 0x2f );
276             break;
277         }
278         break;
279     case 0xde:
280        switch(LOBYTE(context->Eax))
281        {
282        case 0x01:   /* Quarterdeck QDPMI.SYS - DESQview */
283            if(BX_reg(context) == 0x4450 && CX_reg(context) == 0x4d49
284              && DX_reg(context) == 0x8f4f)
285                TRACE("Check for QDPMI.SYS (not installed)\n");
286                break;
287        default:
288            INT_BARF( context, 0x2f );
289            break;
290        }
291        break;
292     case 0xfa:  /* Watcom debugger check, returns 0x666 if installed */
293         break;
294     default:
295         INT_BARF( context, 0x2f );
296         break;
297     }
298 }
299
300
301 /**********************************************************************
302  *         do_int2f_16
303  */
304 static void do_int2f_16( CONTEXT86 *context )
305 {
306     DWORD addr;
307
308     switch(LOBYTE(context->Eax))
309     {
310     case 0x00:  /* Windows enhanced mode installation check */
311         SET_AX( context, (GetWinFlags16() & WF_ENHANCED) ? LOWORD(GetVersion16()) : 0 );
312         break;
313
314     case 0x0a:  /* Get Windows version and type */
315         SET_AX( context, 0 );
316         SET_BX( context, (LOWORD(GetVersion16()) << 8) | (LOWORD(GetVersion16()) >> 8) );
317         SET_CX( context, (GetWinFlags16() & WF_ENHANCED) ? 3 : 2 );
318         break;
319
320     case 0x0b:  /* Identify Windows-aware TSRs */
321         /* we don't have any pre-Windows TSRs */
322         break;
323
324     case 0x11:  /* Get Shell Parameters - (SHELL= in CONFIG.SYS) */
325         /* We can mock this up. But not today... */
326         FIXME("Get Shell Parameters\n");
327         break;
328
329     case 0x80:  /* Release time-slice */
330        /* Linux sched_yield() still keeps burning CPU cycles
331         * if the current process is the only one in highest priority list
332         * (as Linux will immediately return to this process to waste
333         * more CPU cycles), so sched_yield() is essentially useless for us
334         * (poor API, if you ask me: its return code should indicate
335         * whether other processes did run in between, in order for us
336         * to be able to decide whether to do an additional Sleep() or not...)
337         * Thus we better unconditionally use a well-balanced Sleep()
338         * instead to really make sure the process calling int 0x2f/0x1680
339         * *doesn't* use 100% CPU...
340         */
341        Sleep(55); /* just wait 55ms (one "timer tick") for now. */
342        SET_AL( context, 0 );
343         break;
344
345     case 0x81: /* Begin critical section.  */
346         /* FIXME? */
347         break;
348
349     case 0x82: /* End critical section.  */
350         /* FIXME? */
351         break;
352
353     case 0x83:  /* Return Current Virtual Machine ID */
354         /* Virtual Machines are usually created/destroyed when Windows runs
355          * DOS programs. Since we never do, we are always in the System VM.
356          * According to Ralf Brown's Interrupt List, never return 0. But it
357          * seems to work okay (returning 0), just to be sure we return 1.
358          */
359        SET_BX( context, 1 ); /* VM 1 is probably the System VM */
360        break;
361
362     case 0x84:  /* Get device API entry point */
363         {
364             HMODULE16 mod = GetModuleHandle16("wprocs");
365             if (mod < 32) mod = LoadLibrary16( "wprocs" );
366             addr = (DWORD)GetProcAddress16( mod, (LPCSTR)(VXD_BASE + BX_reg(context)) );
367             if (!addr)  /* not supported */
368                 ERR("Accessing unknown VxD %04x - Expect a failure now.\n", BX_reg(context) );
369             context->SegEs = SELECTOROF(addr);
370             SET_DI( context, OFFSETOF(addr) );
371         }
372        break;
373
374     case 0x86:  /* DPMI detect mode */
375         SET_AX( context, 0 );  /* Running under DPMI */
376         break;
377
378     case 0x87: /* DPMI installation check */
379         {
380            SYSTEM_INFO si;
381            GetSystemInfo(&si);
382            SET_AX( context, 0x0000 ); /* DPMI Installed */
383             SET_BX( context, 0x0001 ); /* 32bits available */
384             SET_CL( context, si.wProcessorLevel );
385             SET_DX( context, 0x005a ); /* DPMI major/minor 0.90 */
386             SET_SI( context, 0 );      /* # of para. of DOS extended private data */
387             context->SegEs = DOSVM_dpmi_segments->dpmi_seg;
388             SET_DI( context, 0 );      /* ES:DI is DPMI switch entry point */
389             break;
390         }
391     case 0x8a:  /* DPMI get vendor-specific API entry point. */
392        /* The 1.0 specs say this should work with all 0.9 hosts.  */
393        break;
394
395     default:
396         INT_BARF( context, 0x2f );
397     }
398 }
399
400 /* FIXME: this macro may have to be changed on architectures where <size> reads/writes
401  * must be <size> aligned
402  * <size> could be WORD, DWORD...
403  * in this case, we would need two macros, one for read, the other one for write
404  * Note: PTR_AT can be used as an l-value
405  */
406 #define        PTR_AT(_ptr, _ofs, _typ)        (*((_typ*)(((char*)_ptr)+(_ofs))))
407
408 /* Use #if 1 if you want full int 2f debug... normal users can leave it at 0 */
409 #if 0
410 /**********************************************************************
411  *         MSCDEX_Dump                                 [internal]
412  *
413  * Dumps mscdex requests to int debug channel.
414  */
415 static void    MSCDEX_Dump(char* pfx, BYTE* req, int dorealmode)
416 {
417     int        i;
418     BYTE       buf[2048];
419     BYTE*      ptr;
420     BYTE*      ios;
421
422     ptr = buf;
423     ptr += sprintf(ptr, "%s\tCommand => ", pfx);
424     for (i = 0; i < req[0]; i++) {
425        ptr += sprintf(ptr, "%02x ", req[i]);
426     }
427
428     switch (req[2]) {
429     case 3:
430     case 12:
431        ptr += sprintf(ptr, "\n\t\t\t\tIO_struct => ");
432        ios = (dorealmode) ? PTR_REAL_TO_LIN( PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD)) :
433                              MapSL(MAKESEGPTR(PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD)));
434
435        for (i = 0; i < PTR_AT(req, 18, WORD); i++) {
436            ptr += sprintf(ptr, "%02x ", ios[i]);
437            if ((i & 0x1F) == 0x1F) {
438                *ptr++ = '\n';
439                *ptr = 0;
440            }
441        }
442        break;
443     }
444     TRACE("%s\n", buf);
445 }
446 #else
447 #define MSCDEX_Dump(pfx, req, drm)
448 #endif
449
450 #define CDFRAMES_PERSEC                 75
451 #define CDFRAMES_PERMIN                 (CDFRAMES_PERSEC * 60)
452 #define FRAME_OF_ADDR(a)        ((a)[1] * CDFRAMES_PERMIN + (a)[2] * CDFRAMES_PERSEC + (a)[3])
453 #define FRAME_OF_TOC(toc, idx)  FRAME_OF_ADDR((toc).TrackData[idx - (toc).FirstTrack].Address)
454 #define CTRL_OF_TOC(toc, idx)   (((toc).TrackData[idx - (toc).FirstTrack].Control << 4) | \
455                                   (toc).TrackData[idx - (toc).FirstTrack].Adr)
456
457 static void    MSCDEX_StoreMSF(DWORD frame, BYTE* val)
458 {
459     val[3] = 0;        /* zero */
460     val[2] = frame / CDFRAMES_PERMIN; /* minutes */
461     val[1] = (frame / CDFRAMES_PERSEC) % 60; /* seconds */
462     val[0] = frame % CDFRAMES_PERSEC; /* frames */
463 }
464
465 static int is_cdrom( int drive)
466 {
467     char root[] = "A:\\";
468     root[0] += drive;
469     return (GetDriveTypeA(root) == DRIVE_CDROM);
470 }
471
472 static void MSCDEX_Handler(CONTEXT86* context)
473 {
474     int        drive, count;
475     char*      p;
476
477     switch (LOBYTE(context->Eax)) {
478     case 0x00: /* Installation check */
479        /* Count the number of contiguous CDROM drives
480         */
481        for (drive = count = 0; drive < 26; drive++) {
482            if (is_cdrom(drive)) {
483                while (is_cdrom(drive + count)) count++;
484                break;
485            }
486        }
487        TRACE("Installation check: %d cdroms, starting at %d\n", count, drive);
488        SET_BX( context, count );
489        SET_CX( context, (drive < 26) ? drive : 0 );
490        break;
491
492     case 0x0B: /* drive check */
493        SET_AX( context, is_cdrom(CX_reg(context)) );
494        SET_BX( context, 0xADAD );
495        break;
496
497     case 0x0C: /* get version */
498        SET_BX( context, 0x020a );
499        TRACE("Version number => %04x\n", BX_reg(context));
500        break;
501
502     case 0x0D: /* get drive letters */
503        p = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Ebx);
504        memset(p, 0, 26);
505        for (drive = 0; drive < 26; drive++) {
506            if (is_cdrom(drive)) *p++ = drive;
507        }
508        TRACE("Get drive letters\n");
509        break;
510
511     case 0x10: /* direct driver access */
512        {
513            BYTE*       driver_request;
514            BYTE*       io_stru;
515            BYTE        Error = 255; /* No Error */
516            int         dorealmode = ISV86(context);
517             char        devName[] = "\\\\.\\@:";
518            HANDLE      h;
519             CDROM_TOC                   toc;
520             CDROM_SUB_Q_DATA_FORMAT     fmt;
521             SUB_Q_CHANNEL_DATA          data;
522             DWORD                       br;
523             DWORD                       present = TRUE;
524
525            driver_request = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Ebx);
526
527            if (!driver_request) {
528                /* FIXME - to be deleted ?? */
529                ERR("ES:BX==0 ! SEGFAULT ?\n");
530                ERR("-->BX=0x%04x, ES=0x%04lx, DS=0x%04lx, CX=0x%04x\n",
531                    BX_reg(context), context->SegEs, context->SegDs, CX_reg(context));
532                driver_request[4] |= 0x80;
533                driver_request[3] = 5;  /* bad request length */
534                return;
535            }
536            /* FIXME
537              * the following tests are wrong because lots of functions don't require the
538              * tray to be closed with a CD inside
539             */
540            TRACE("CDROM device driver -> command <%d>\n", (unsigned char)driver_request[2]);
541
542            if (!is_cdrom(CX_reg(context))) {
543                WARN("Request made doesn't match a CD ROM drive (%d)\n", CX_reg(context));
544                driver_request[4] |= 0x80;
545                driver_request[3] = 1;  /* unknown unit */
546                return;
547            }
548
549            MSCDEX_Dump("Beg", driver_request, dorealmode);
550
551            /* set status to 0 */
552            PTR_AT(driver_request, 3, WORD) = 0;
553             devName[4] = 'A' + CX_reg(context);
554             h = CreateFileA(devName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
555             if (!h) {
556                WARN("Couldn't open cdrom handle\n");
557                driver_request[4] |= 0x80;
558                driver_request[3] = 1;  /* unknown unit */
559                return;
560            }
561
562             fmt.Format = IOCTL_CDROM_CURRENT_POSITION;
563             if (!DeviceIoControl(h, IOCTL_CDROM_READ_TOC, NULL, 0, &toc, sizeof(toc), &br, NULL) ||
564                 !DeviceIoControl(h, IOCTL_CDROM_READ_Q_CHANNEL, &fmt, sizeof(fmt),
565                                  &data, sizeof(data), &br, NULL)) {
566                 if (GetLastError() == STATUS_NO_MEDIA_IN_DEVICE)
567                 {
568                     if (driver_request[2] != 6 && driver_request[2] != 15)
569                     {
570                         driver_request[4] |= 0x80;
571                         driver_request[3] = 2; /* drive not ready */
572                         CloseHandle(h);
573                         return;
574                     }
575                     present = FALSE;
576                 }
577                 else
578                 {
579                     driver_request[4] |= 0x80;
580                     driver_request[3] = 1;     /* unknown unit */
581                     CloseHandle(h);
582                     return;
583                 }
584             }
585
586            switch (driver_request[2]) {
587            case 3:
588                io_stru = (dorealmode) ?
589                     PTR_REAL_TO_LIN( PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD) ) :
590                        MapSL( MAKESEGPTR(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)));
591
592                TRACE(" --> IOCTL INPUT <%d>\n", io_stru[0]);
593                switch (io_stru[0]) {
594 #if 0
595                case 0: /* Get device Header */
596                    {
597                        static  LPSTR ptr = 0;
598                        if (ptr == 0)   {
599                            ptr = SEGPTR_ALLOC(22);
600                            PTR_AT(ptr,  0, DWORD) = ~1;        /* Next Device Driver */
601                            PTR_AT(ptr,  4,  WORD) = 0xC800;    /* Device attributes  */
602                            PTR_AT(ptr,  6,  WORD) = 0x1234;    /* Pointer to device strategy routine: FIXME */
603                            PTR_AT(ptr,  8,  WORD) = 0x3142;    /* Pointer to device interrupt routine: FIXME */
604                            PTR_AT(ptr, 10,  char) = 'W';       /* 8-byte character device name field */
605                            PTR_AT(ptr, 11,  char) = 'I';
606                            PTR_AT(ptr, 12,  char) = 'N';
607                            PTR_AT(ptr, 13,  char) = 'E';
608                            PTR_AT(ptr, 14,  char) = '_';
609                            PTR_AT(ptr, 15,  char) = 'C';
610                            PTR_AT(ptr, 16,  char) = 'D';
611                            PTR_AT(ptr, 17,  char) = '_';
612                            PTR_AT(ptr, 18,  WORD) = 0;         /* Reserved (must be zero) */
613                            PTR_AT(ptr, 20,  BYTE) = 0;         /* Drive letter (must be zero) */
614                            PTR_AT(ptr, 21,  BYTE) = 1;         /* Number of units supported (one or more) FIXME*/
615                        }
616                        PTR_AT(io_stru, DWORD,  0) = SEGPTR_GET(ptr);
617                    }
618                    break;
619 #endif
620
621                case 1: /* location of head */
622                    switch (io_stru[1]) {
623                    case 0:
624                        PTR_AT(io_stru, 2, DWORD) =
625                             FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress);
626                        break;
627                    case 1:
628                        MSCDEX_StoreMSF(FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress),
629                                         io_stru + 2);
630                        break;
631                    default:
632                        ERR("CD-ROM driver: unsupported addressing mode !!\n");
633                        Error = 0x0c;
634                    }
635                    TRACE(" ----> HEAD LOCATION <%ld>\n", PTR_AT(io_stru, 2, DWORD));
636                    break;
637
638                case 4: /* Audio channel info */
639                    io_stru[1] = 0;
640                    io_stru[2] = 0xff;
641                    io_stru[3] = 1;
642                    io_stru[4] = 0xff;
643                    io_stru[5] = 2;
644                    io_stru[6] = 0;
645                    io_stru[7] = 3;
646                    io_stru[8] = 0;
647                    TRACE(" ----> AUDIO CHANNEL INFO\n");
648                    break;
649
650                case 6: /* device status */
651                    PTR_AT(io_stru, 1, DWORD) = 0x00000290;
652                    /* 290 =>
653                     * 1        Supports HSG and Red Book addressing modes
654                     * 0        Supports audio channel manipulation
655                     *
656                     * 1        Supports prefetching requests
657                     * 0        Reserved
658                     * 0        No interleaving
659                     * 1        Data read and plays audio/video tracks
660                     *
661                     * 0        Read only
662                     * 0        Supports only cooked reading
663                     * 0        Door locked
664                     * 0        see below (Door closed/opened)
665                     */
666                    if (!present) PTR_AT(io_stru, 1, DWORD) |= 1;
667                    TRACE(" ----> DEVICE STATUS <0x%08lx>\n", PTR_AT(io_stru, 1, DWORD));
668                    break;
669
670                case 8: /* Volume size */
671                    PTR_AT(io_stru, 1, DWORD) = FRAME_OF_TOC(toc, toc.LastTrack + 1) -
672                         FRAME_OF_TOC(toc, toc.FirstTrack) - 1;
673                    TRACE(" ----> VOLUME SIZE <%ld>\n", PTR_AT(io_stru, 1, DWORD));
674                    break;
675
676                case 9: /* media changed ? */
677                    /* answers don't know... -1/1 for yes/no would be better */
678                    io_stru[1] = 0; /* FIXME? 1? */
679                    TRACE(" ----> MEDIA CHANGED <%d>\n", io_stru[1]);
680                    break;
681
682                case 10: /* audio disk info */
683                    io_stru[1] = toc.FirstTrack; /* starting track of the disc */
684                    io_stru[2] = toc.LastTrack;  /* ending track */
685                    MSCDEX_StoreMSF(FRAME_OF_TOC(toc, toc.LastTrack + 1) -
686                                     FRAME_OF_TOC(toc, toc.FirstTrack) - 1, io_stru + 3);
687
688                    TRACE(" ----> AUDIO DISK INFO <%d-%d/%08lx>\n",
689                          io_stru[1], io_stru[2], PTR_AT(io_stru, 3, DWORD));
690                    break;
691
692                case 11: /* audio track info */
693                    if (io_stru[1] >= toc.FirstTrack && io_stru[1] <= toc.LastTrack) {
694                        MSCDEX_StoreMSF(FRAME_OF_TOC(toc, io_stru[1]), io_stru + 2);
695                        /* starting point if the track */
696                        io_stru[6] = CTRL_OF_TOC(toc, io_stru[1]);
697                    } else {
698                        PTR_AT(io_stru, 2, DWORD) = 0;
699                        io_stru[6] = 0;
700                    }
701                    TRACE(" ----> AUDIO TRACK INFO[%d] = [%08lx:%d]\n",
702                          io_stru[1], PTR_AT(io_stru, 2, DWORD), io_stru[6]);
703                    break;
704
705                case 12: /* get Q-Channel info */
706                    io_stru[1] = CTRL_OF_TOC(toc, data.CurrentPosition.TrackNumber);
707                    io_stru[2] = data.CurrentPosition.TrackNumber;
708                    io_stru[3] = 0; /* FIXME ?? */
709
710                    /* why the heck did MS use another format for 0MSF information... sigh */
711                    {
712                        BYTE    bTmp[4];
713
714                        MSCDEX_StoreMSF(FRAME_OF_ADDR(data.CurrentPosition.TrackRelativeAddress), bTmp);
715                        io_stru[ 4] = bTmp[2];
716                        io_stru[ 5] = bTmp[1];
717                        io_stru[ 6] = bTmp[0];
718                        io_stru[ 7] = 0;
719
720                        MSCDEX_StoreMSF(FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress), bTmp);
721                        io_stru[ 8] = bTmp[2];
722                        io_stru[ 9] = bTmp[1];
723                        io_stru[10] = bTmp[0];
724                        io_stru[11] = 0;
725                    }
726                    TRACE("Q-Channel info: Ctrl/adr=%02x TNO=%02x X=%02x rtt=%02x:%02x:%02x rtd=%02x:%02x:%02x (cf=%08x, tp=%08x)\n",
727                          io_stru[ 1], io_stru[ 2], io_stru[ 3],
728                          io_stru[ 4], io_stru[ 5], io_stru[ 6],
729                          io_stru[ 8], io_stru[ 9], io_stru[10],
730                          FRAME_OF_ADDR(data.CurrentPosition.AbsoluteAddress),
731                           FRAME_OF_TOC(toc, data.CurrentPosition.TrackNumber));
732                    break;
733
734                case 15: /* Audio status info */
735                    /* !!!! FIXME FIXME FIXME !! */
736                    PTR_AT(io_stru, 1,  WORD) = 2 | ((data.CurrentPosition.Header.AudioStatus == AUDIO_STATUS_PAUSED) ? 1 : 0);
737                    if (!present) {
738                        PTR_AT(io_stru, 3, DWORD) = 0;
739                        PTR_AT(io_stru, 7, DWORD) = 0;
740                    } else {
741                        PTR_AT(io_stru, 3, DWORD) = FRAME_OF_TOC(toc, toc.FirstTrack);
742                        PTR_AT(io_stru, 7, DWORD) = FRAME_OF_TOC(toc, toc.LastTrack + 1);
743                    }
744                    TRACE("Audio status info: status=%04x startLoc=%ld endLoc=%ld\n",
745                          PTR_AT(io_stru, 1, WORD), PTR_AT(io_stru, 3, DWORD), PTR_AT(io_stru, 7, DWORD));
746                    break;
747
748                default:
749                    FIXME("IOCTL INPUT: Unimplemented <%d>!!\n", io_stru[0]);
750                    Error = 0x0c;
751                    break;
752                }
753                break;
754
755            case 12:
756                io_stru = (dorealmode) ?
757                    PTR_REAL_TO_LIN( PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)) :
758                        MapSL( MAKESEGPTR(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)));
759
760                TRACE(" --> IOCTL OUTPUT <%d>\n", io_stru[0]);
761                switch (io_stru[0]) {
762                case 0: /* eject */
763                     DeviceIoControl(h, IOCTL_STORAGE_EJECT_MEDIA, NULL, 0, NULL, 0, &br, NULL);
764                    TRACE(" ----> EJECT\n");
765                    break;
766                case 2: /* reset drive */
767                    DeviceIoControl(h, IOCTL_STORAGE_RESET_DEVICE, NULL, 0, NULL, 0, &br, NULL);
768                    TRACE(" ----> RESET\n");
769                    break;
770                case 3: /* Audio Channel Control */
771                    FIXME(" ----> AUDIO CHANNEL CONTROL (NIY)\n");
772                    break;
773                case 5: /* close tray */
774                     DeviceIoControl(h, IOCTL_STORAGE_LOAD_MEDIA, NULL, 0, NULL, 0, &br, NULL);
775                    TRACE(" ----> CLOSE TRAY\n");
776                    break;
777                default:
778                    FIXME(" IOCTL OUTPUT: Unimplemented <%d>!!\n", io_stru[0]);
779                    Error = 0x0c;
780                    break;
781                }
782                break;
783
784             case 128: /* read long */
785                 {
786                     LPVOID              dst = MapSL(MAKESEGPTR(PTR_AT(driver_request, 16, WORD),
787                                                                PTR_AT(driver_request, 14, WORD)));
788                     DWORD               at = PTR_AT(driver_request, 20, DWORD);
789                     WORD                num = PTR_AT(driver_request, 18, WORD);
790                     RAW_READ_INFO       rri;
791
792                    switch (driver_request[13]) {
793                    case 1: /* Red book addressing mode = 0:m:s:f */
794                        /* FIXME : frame <=> msf conversion routines could be shared
795                         * between mscdex and mcicda
796                         */
797                        at = LOBYTE(HIWORD(at)) * CDFRAMES_PERMIN +
798                            HIBYTE(LOWORD(at)) * CDFRAMES_PERSEC +
799                            LOBYTE(LOWORD(at));
800                        /* fall through */
801                    case 0: /* HSG addressing mode */
802                         switch (PTR_AT(driver_request, 24, BYTE))
803                         {
804                         case 0: /* cooked */
805                             ReadFile(h, dst, num * 2048, &br, NULL);
806                             break;
807                         case 1:
808                             /* FIXME: computation is wrong */
809                             rri.DiskOffset.u.HighPart = 0;
810                             rri.DiskOffset.u.LowPart = at << 11;
811                             rri.TrackMode = YellowMode2;
812                             rri.SectorCount = num;
813                             DeviceIoControl(h, IOCTL_CDROM_RAW_READ, &rri, sizeof(rri),
814                                             dst, num * 2352, &br, NULL);
815                        break;
816                         default:
817                             ERR("Unsupported read mode !!\n");
818                             Error = 0x0c;
819                             break;
820                         }
821                         break;
822                    default:
823                        ERR("Unsupported address mode !!\n");
824                        Error = 0x0c;
825                        break;
826                    }
827                 }
828                 break;
829
830            case 131: /* seek */
831                {
832                    DWORD                       at;
833                     CDROM_SEEK_AUDIO_MSF        seek;
834
835                    at = PTR_AT(driver_request, 20, DWORD);
836
837                    TRACE(" --> SEEK AUDIO mode :<0x%02X>, [%ld]\n",
838                          (BYTE)driver_request[13], at);
839
840                    switch (driver_request[13]) {
841                    case 1: /* Red book addressing mode = 0:m:s:f */
842                        /* FIXME : frame <=> msf conversion routines could be shared
843                         * between mscdex and mcicda
844                         */
845                        at = LOBYTE(HIWORD(at)) * CDFRAMES_PERMIN +
846                            HIBYTE(LOWORD(at)) * CDFRAMES_PERSEC +
847                            LOBYTE(LOWORD(at));
848                        /* fall through */
849                    case 0: /* HSG addressing mode */
850                         seek.M = at / CDFRAMES_PERMIN;
851                         seek.S = (at / CDFRAMES_PERSEC) % 60;
852                         seek.F = at % CDFRAMES_PERSEC;
853                         DeviceIoControl(h, IOCTL_CDROM_SEEK_AUDIO_MSF, &seek, sizeof(seek),
854                                         NULL, 0, &br, NULL);
855                        break;
856                    default:
857                        ERR("Unsupported address mode !!\n");
858                        Error = 0x0c;
859                        break;
860                    }
861                }
862                break;
863
864            case 132: /* play */
865                {
866                    DWORD                       beg, end;
867                     CDROM_PLAY_AUDIO_MSF        play;
868
869                    beg = end = PTR_AT(driver_request, 14, DWORD);
870                    end += PTR_AT(driver_request, 18, DWORD);
871
872                    TRACE(" --> PLAY AUDIO mode :<0x%02X>, [%ld-%ld]\n",
873                          (BYTE)driver_request[13], beg, end);
874
875                    switch (driver_request[13]) {
876                    case 1:
877                        /* Red book addressing mode = 0:m:s:f */
878                        /* FIXME : frame <=> msf conversion routines could be shared
879                         * between mscdex and mcicda
880                         */
881                        beg = LOBYTE(LOWORD(beg)) * CDFRAMES_PERMIN +
882                            HIBYTE(LOWORD(beg)) * CDFRAMES_PERSEC +
883                            LOBYTE(HIWORD(beg));
884                        end = LOBYTE(LOWORD(end)) * CDFRAMES_PERMIN +
885                            HIBYTE(LOWORD(end)) * CDFRAMES_PERSEC +
886                            LOBYTE(HIWORD(end));
887                        /* fall through */
888                    case 0: /* HSG addressing mode */
889                         play.StartingM = beg / CDFRAMES_PERMIN;
890                         play.StartingS = (beg / CDFRAMES_PERSEC) % 60;
891                         play.StartingF = beg % CDFRAMES_PERSEC;
892                         play.EndingM   = end / CDFRAMES_PERMIN;
893                         play.EndingS   = (end / CDFRAMES_PERSEC) % 60;
894                         play.EndingF   = end % CDFRAMES_PERSEC;
895                         DeviceIoControl(h, IOCTL_CDROM_PLAY_AUDIO_MSF, &play, sizeof(play),
896                                         NULL, 0, &br, NULL);
897                        break;
898                    default:
899                        ERR("Unsupported address mode !!\n");
900                        Error = 0x0c;
901                        break;
902                    }
903                }
904                break;
905
906            case 133:
907                if (data.CurrentPosition.Header.AudioStatus == AUDIO_STATUS_IN_PROGRESS) {
908                     DeviceIoControl(h, IOCTL_CDROM_PAUSE_AUDIO, NULL, 0, NULL, 0, &br, NULL);
909                    TRACE(" --> STOP AUDIO (Paused)\n");
910                } else {
911                     DeviceIoControl(h, IOCTL_CDROM_STOP_AUDIO, NULL, 0, NULL, 0, &br, NULL);
912                    TRACE(" --> STOP AUDIO (Stopped)\n");
913                }
914                break;
915
916            case 136:
917                TRACE(" --> RESUME AUDIO\n");
918                 DeviceIoControl(h, IOCTL_CDROM_PAUSE_AUDIO, NULL, 0, NULL, 0, &br, NULL);
919                break;
920
921            default:
922                FIXME(" ioctl unimplemented <%d>\n", driver_request[2]);
923                Error = 0x0c;
924            }
925
926            /* setting error codes if any */
927            if (Error < 255) {
928                driver_request[4] |= 0x80;
929                driver_request[3] = Error;
930            }
931
932            CloseHandle(h);
933            /* setting status bits
934             * 3 == playing && done
935             * 1 == done
936             */
937            driver_request[4] |=
938                 (data.CurrentPosition.Header.AudioStatus == AUDIO_STATUS_IN_PROGRESS) ? 3 : 1;
939
940            MSCDEX_Dump("End", driver_request, dorealmode);
941        }
942        break;
943     default:
944        FIXME("Unimplemented MSCDEX function 0x%02X.\n", LOBYTE(context->Eax));
945        break;
946     }
947 }