?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added assembly wrapper for calling window procedures.
[wine.git] / msdos / int2f.c
blobe52149f36bafc5da9a26b3f38a40a285a8ed146e
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * DOS interrupt 2fh handler
4 *
5 * Cdrom - device driver emulation - Audio features.
6 * (c) 1998 Petr Tomasek <tomasek@etf.cuni.cz>
7 * (c) 1999 Eric Pouech
8 */
9
10 #include "config.h"
11
12 #include <stdlib.h>
13 #include <string.h>
14 #include <unistd.h>
15
16 #include "wine/winbase16.h"
17 #include "ldt.h"
18 #include "drive.h"
19 #include "msdos.h"
20 #include "miscemu.h"
21 #include "module.h"
22 #include "task.h"
23 #include "dosexe.h"
24 #include "heap.h"
25 /* #define DEBUG_INT */
26 #include "debugtools.h"
27 #include "cdrom.h"
28
29 DEFAULT_DEBUG_CHANNEL(int)
30
31 /* base WPROCS.DLL ordinal number for VxDs */
32 #define VXD_BASE 400
33
34 static void do_int2f_16( CONTEXT86 *context );
35 static void MSCDEX_Handler( CONTEXT86 *context );
36
37 /**********************************************************************
38 * INT_Int2fHandler
39 *
40 * Handler for int 2fh (multiplex).
41 */
42 void WINAPI INT_Int2fHandler( CONTEXT86 *context )
43 {
44 TRACE("Subfunction 0x%X\n", AX_reg(context));
45
46 switch(AH_reg(context))
47 {
48 case 0x10:
49 AL_reg(context) = 0xff; /* share is installed */
50 break;
51
52 case 0x11: /* Network Redirector / IFSFUNC */
53 switch (AL_reg(context))
54 {
55 case 0x00: /* Install check */
56 /* not installed */
57 break;
58 case 0x80: /* Enhanced services - Install check */
59 /* not installed */
60 break;
61 default:
62 INT_BARF( context, 0x2f );
63 break;
64 }
65 break;
66
67 case 0x12:
68 switch (AL_reg(context))
69 {
70 case 0x2e: /* get or set DOS error table address */
71 switch (DL_reg(context))
72 {
73 /* Four tables: even commands are 'get', odd are 'set' */
74 /* DOS 5.0+ ignores "set" commands */
75 case 0x01:
76 case 0x03:
77 case 0x05:
78 case 0x07:
79 case 0x09:
80 break;
81 /* Instead of having a message table in DOS-space, */
82 /* we can use a special case for MS-DOS to force */
83 /* the secondary interface. */
84 case 0x00:
85 case 0x02:
86 case 0x04:
87 case 0x06:
88 ES_reg(context) = 0x0001;
89 DI_reg(context) = 0x0000;
90 break;
91 case 0x08:
92 FIXME("No real-mode handler for errors yet! (bye!)");
93 break;
94 default:
95 INT_BARF(context, 0x2f);
96 }
97 break;
98 default:
99 INT_BARF(context, 0x2f);
100 }
101 break;
102
103 case 0x15: /* mscdex */
104 MSCDEX_Handler(context);
105 break;
106
107 case 0x16:
108 do_int2f_16( context );
109 break;
110
111 case 0x1a: /* ANSI.SYS / AVATAR.SYS Install Check */
112 /* Not supported yet, do nothing */
113 break;
114
115 case 0x43:
116 #if 1
117 switch (AL_reg(context))
118 {
119 case 0x00: /* XMS v2+ installation check */
120 WARN("XMS is not fully implemented\n");
121 AL_reg(context) = 0x80;
122 break;
123 case 0x10: /* XMS v2+ get driver address */
124 {
125 #ifdef MZ_SUPPORTED
126 TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
127 NE_MODULE *pModule = pTask ? NE_GetPtr( pTask->hModule ) : NULL;
128 GlobalUnlock16( GetCurrentTask() );
129
130 if (pModule && pModule->lpDosTask)
131 ES_reg(context) = pModule->lpDosTask->xms_seg;
132 else
133 #endif
134 ES_reg(context) = 0;
135 BX_reg(context) = 0;
136 break;
137 }
138 default:
139 INT_BARF( context, 0x2f );
140 }
141 #else
142 FIXME("check for XMS (not supported)\n");
143 AL_reg(context) = 0x42; /* != 0x80 */
144 #endif
145 break;
146
147 case 0x45:
148 switch (AL_reg(context))
149 {
150 case 0x00:
151 case 0x01:
152 case 0x02:
153 case 0x03:
154 case 0x04:
155 case 0x05:
156 case 0x06:
157 case 0x07:
158 case 0x08:
159 /* Microsoft Profiler - not installed */
160 break;
161 default:
162 INT_BARF( context, 0x2f );
163 }
164 break;
165
166 case 0x4a:
167 switch(AL_reg(context))
168 {
169 case 0x10: /* smartdrv */
170 break; /* not installed */
171 case 0x11: /* dblspace */
172 break; /* not installed */
173 case 0x12: /* realtime compression interface */
174 break; /* not installed */
175 case 0x32: /* patch IO.SYS (???) */
176 break; /* we have no IO.SYS, so we can't patch it :-/ */
177 default:
178 INT_BARF( context, 0x2f );
179 }
180 break;
181 case 0x4b:
182 switch(AL_reg(context))
183 {
184 case 0x01:
185 case 0x02:
186 case 0x03:
187 case 0x04:
188 case 0x05:
189 FIXME("Task Switcher - not implemented\n");
190 break;
191 default:
192 INT_BARF( context, 0x2f );
193 }
194 break;
195 case 0x56: /* INTERLNK */
196 switch(AL_reg(context))
197 {
198 case 0x01: /* check if redirected drive */
199 AL_reg(context) = 0; /* not redirected */
200 break;
201 default:
202 INT_BARF( context, 0x2f );
203 }
204 break;
205 case 0x7a: /* NOVELL NetWare */
206 switch (AL_reg(context))
207 {
208 case 0x0: /* Low-level Netware installation check AL=0 not installed.*/
209 AL_reg(context) = 0;
210 break;
211 case 0x20: /* Get VLM Call Address */
212 /* return nothing -> NetWare not installed */
213 break;
214 default:
215 INT_BARF( context, 0x2f );
216 break;
217 }
218 break;
219 case 0xb7: /* append */
220 AL_reg(context) = 0; /* not installed */
221 break;
222 case 0xb8: /* network */
223 switch (AL_reg(context))
224 {
225 case 0x00: /* Install check */
226 /* not installed */
227 break;
228 default:
229 INT_BARF( context, 0x2f );
230 break;
231 }
232 break;
233 case 0xbd: /* some Novell network install check ??? */
234 AX_reg(context) = 0xa5a5; /* pretend to have Novell IPX installed */
235 break;
236 case 0xbf: /* REDIRIFS.EXE */
237 switch (AL_reg(context))
238 {
239 case 0x00: /* Install check */
240 /* not installed */
241 break;
242 default:
243 INT_BARF( context, 0x2f );
244 break;
245 }
246 break;
247 case 0xd2:
248 switch(AL_reg(context))
249 {
250 case 0x01: /* Quarterdeck RPCI - QEMM/QRAM - PCL-838.EXE functions */
251 if(BX_reg(context) == 0x5145 && CX_reg(context) == 0x4D4D
252 && DX_reg(context) == 0x3432)
253 TRACE("Check for QEMM v5.0+ (not installed)\n");
254 break;
255 default:
256 INT_BARF( context, 0x2f );
257 break;
258 }
259 break;
260 case 0xd7: /* Banyan Vines */
261 switch (AL_reg(context))
262 {
263 case 0x01: /* Install check - Get Int Number */
264 /* not installed */
265 break;
266 default:
267 INT_BARF( context, 0x2f );
268 break;
269 }
270 break;
271 case 0xde:
272 switch(AL_reg(context))
273 {
274 case 0x01: /* Quarterdeck QDPMI.SYS - DESQview */
275 if(BX_reg(context) == 0x4450 && CX_reg(context) == 0x4d49
276 && DX_reg(context) == 0x8f4f)
277 TRACE("Check for QDPMI.SYS (not installed)\n");
278 break;
279 default:
280 INT_BARF( context, 0x2f );
281 break;
282 }
283 break;
284 case 0xfa: /* Watcom debugger check, returns 0x666 if installed */
285 break;
286 default:
287 INT_BARF( context, 0x2f );
288 break;
289 }
290 }
291
292
293 /**********************************************************************
294 * do_int2f_16
295 */
296 static void do_int2f_16( CONTEXT86 *context )
297 {
298 DWORD addr;
299
300 switch(AL_reg(context))
301 {
302 case 0x00: /* Windows enhanced mode installation check */
303 AX_reg(context) = (GetWinFlags16() & WF_ENHANCED) ?
304 LOWORD(GetVersion16()) : 0;
305 break;
306
307 case 0x0a: /* Get Windows version and type */
308 AX_reg(context) = 0;
309 BX_reg(context) = (LOWORD(GetVersion16()) << 8) |
310 (LOWORD(GetVersion16()) >> 8);
311 CX_reg(context) = (GetWinFlags16() & WF_ENHANCED) ? 3 : 2;
312 break;
313
314 case 0x0b: /* Identify Windows-aware TSRs */
315 /* we don't have any pre-Windows TSRs */
316 break;
317
318 case 0x11: /* Get Shell Parameters - (SHELL= in CONFIG.SYS) */
319 /* We can mock this up. But not today... */
320 FIXME("Get Shell Parameters\n");
321 break;
322
323 case 0x80: /* Release time-slice */
324 AL_reg(context) = 0;
325 break;
326
327 case 0x81: /* Begin critical section. */
328 /* FIXME? */
329 break;
330
331 case 0x82: /* End critical section. */
332 /* FIXME? */
333 break;
334
335 case 0x83: /* Return Current Virtual Machine ID */
336 /* Virtual Machines are usually created/destroyed when Windows runs
337 * DOS programs. Since we never do, we are always in the System VM.
338 * According to Ralf Brown's Interrupt List, never return 0. But it
339 * seems to work okay (returning 0), just to be sure we return 1.
340 */
341 BX_reg(context) = 1; /* VM 1 is probably the System VM */
342 break;
343
344 case 0x84: /* Get device API entry point */
345 addr = (DWORD)NE_GetEntryPoint( GetModuleHandle16("WPROCS"),
346 VXD_BASE + BX_reg(context) );
347 if (!addr) /* not supported */
348 {
349 ERR("Accessing unknown VxD %04x - Expect a failure now.\n",
350 BX_reg(context) );
351 }
352 ES_reg(context) = SELECTOROF(addr);
353 DI_reg(context) = OFFSETOF(addr);
354 break;
355
356 case 0x86: /* DPMI detect mode */
357 AX_reg(context) = 0; /* Running under DPMI */
358 break;
359
360 case 0x87: /* DPMI installation check */
361 #if 1 /* DPMI still breaks pkunzip */
362 if (ISV86(context)) break; /* so bail out for now if in v86 mode */
363 #endif
364 {
365 SYSTEM_INFO si;
366 #ifdef MZ_SUPPORTED
367 TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
368 NE_MODULE *pModule = pTask ? NE_GetPtr( pTask->hModule ) : NULL;
369
370 GlobalUnlock16( GetCurrentTask() );
371 #endif
372
373 GetSystemInfo(&si);
374 AX_reg(context) = 0x0000; /* DPMI Installed */
375 BX_reg(context) = 0x0001; /* 32bits available */
376 CL_reg(context) = si.wProcessorLevel;
377 DX_reg(context) = 0x005a; /* DPMI major/minor 0.90 */
378 SI_reg(context) = 0; /* # of para. of DOS extended private data */
379 #ifdef MZ_SUPPORTED /* ES:DI is DPMI switch entry point */
380 if (pModule && pModule->lpDosTask)
381 ES_reg(context) = pModule->lpDosTask->dpmi_seg;
382 else
383 #endif
384 ES_reg(context) = 0;
385 DI_reg(context) = 0;
386 break;
387 }
388 case 0x8a: /* DPMI get vendor-specific API entry point. */
389 /* The 1.0 specs say this should work with all 0.9 hosts. */
390 break;
391
392 default:
393 INT_BARF( context, 0x2f );
394 }
395 }
396
397 /* FIXME: this macro may have to be changed on architectures where <size> reads/writes
398 * must be <size> aligned
399 * <size> could be WORD, DWORD...
400 * in this case, we would need two macros, one for read, the other one for write
401 * Note: PTR_AT can be used as an l-value
402 */
403 #define PTR_AT(_ptr, _ofs, _typ) (*((_typ*)(((char*)_ptr)+(_ofs))))
404
405 /* Use #if 1 if you want full int 2f debug... normal users can leave it at 0 */
406 #if 0
407 /**********************************************************************
408 * MSCDEX_Dump [internal]
409 *
410 * Dumps mscdex requests to int debug channel.
411 */
412 static void MSCDEX_Dump(char* pfx, BYTE* req, int dorealmode)
413 {
414 int i;
415 BYTE buf[2048];
416 BYTE* ptr;
417 BYTE* ios;
418
419 ptr = buf;
420 ptr += sprintf(ptr, "%s\tCommand => ", pfx);
421 for (i = 0; i < req[0]; i++) {
422 ptr += sprintf(ptr, "%02x ", req[i]);
423 }
424
425 switch (req[2]) {
426 case 3:
427 case 12:
428 ptr += sprintf(ptr, "\n\t\t\t\tIO_struct => ");
429 ios = (dorealmode) ?
430 DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(req, 14, WORD), PTR_AT(req, 16, WORD))) :
431 PTR_SEG_OFF_TO_LIN(PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD));
432
433 for (i = 0; i < PTR_AT(req, 18, WORD); i++) {
434 ptr += sprintf(ptr, "%02x ", ios[i]);
435 if ((i & 0x1F) == 0x1F) {
436 *ptr++ = '\n';
437 *ptr = 0;
438 }
439 }
440 break;
441 }
442 TRACE("%s\n", buf);
443 }
444 #else
445 #define MSCDEX_Dump(pfx, req, drm)
446 #endif
447
448 static void MSCDEX_StoreMSF(DWORD frame, BYTE* val)
449 {
450 val[3] = 0; /* zero */
451 val[2] = frame / CDFRAMES_PERMIN; /* minutes */
452 val[1] = (frame - CDFRAMES_PERMIN * val[2]) / CDFRAMES_PERSEC; /* seconds */
453 val[0] = frame - CDFRAMES_PERMIN * val[2] - CDFRAMES_PERSEC * val[1]; /* frames */
454 }
455
456 static void MSCDEX_Handler(CONTEXT86* context)
457 {
458 int drive, count;
459 char* p;
460
461 switch(AL_reg(context)) {
462 case 0x00: /* Installation check */
463 /* Count the number of contiguous CDROM drives
464 */
465 for (drive = count = 0; drive < MAX_DOS_DRIVES; drive++) {
466 if (DRIVE_GetType(drive) == TYPE_CDROM) {
467 while (DRIVE_GetType(drive + count) == TYPE_CDROM) count++;
468 break;
469 }
470 }
471 TRACE("Installation check: %d cdroms, starting at %d\n", count, drive);
472 BX_reg(context) = count;
473 CX_reg(context) = (drive < MAX_DOS_DRIVES) ? drive : 0;
474 break;
475
476 case 0x0B: /* drive check */
477 AX_reg(context) = (DRIVE_GetType(CX_reg(context)) == TYPE_CDROM);
478 BX_reg(context) = 0xADAD;
479 break;
480
481 case 0x0C: /* get version */
482 BX_reg(context) = 0x020a;
483 TRACE("Version number => %04x\n", BX_reg(context));
484 break;
485
486 case 0x0D: /* get drive letters */
487 p = CTX_SEG_OFF_TO_LIN(context, ES_reg(context), EBX_reg(context));
488 memset(p, 0, MAX_DOS_DRIVES);
489 for (drive = 0; drive < MAX_DOS_DRIVES; drive++) {
490 if (DRIVE_GetType(drive) == TYPE_CDROM) *p++ = drive;
491 }
492 TRACE("Get drive letters\n");
493 break;
494
495 case 0x10: /* direct driver access */
496 {
497 static WINE_CDAUDIO wcda;
498 BYTE* driver_request;
499 BYTE* io_stru;
500 BYTE Error = 255; /* No Error */
501 int dorealmode = ISV86(context);
502
503 driver_request = (dorealmode) ?
504 DOSMEM_MapRealToLinear(MAKELONG(BX_reg(context), ES_reg(context))) :
505 PTR_SEG_OFF_TO_LIN(ES_reg(context), BX_reg(context));
506
507 if (!driver_request) {
508 /* FIXME - to be deleted ?? */
509 ERR("ES:BX==0 ! SEGFAULT ?\n");
510 ERR("-->BX=0x%04x, ES=0x%04lx, DS=0x%04lx, CX=0x%04x\n",
511 BX_reg(context), ES_reg(context), DS_reg(context), CX_reg(context));
512 driver_request[4] |= 0x80;
513 driver_request[3] = 5; /* bad request length */
514 return;
515 }
516 /* FIXME - would be better to open the device at the beginning of the wine session...
517 * - the device is also never closed...
518 * - the current implementation only supports a single CD ROM
519 */
520 if (wcda.unixdev <= 0)
521 CDROM_Open(&wcda, -1);
522 TRACE("CDROM device driver -> command <%d>\n", (unsigned char)driver_request[2]);
523
524 for (drive = 0;
525 drive < MAX_DOS_DRIVES && DRIVE_GetType(drive) != TYPE_CDROM;
526 drive++);
527 /* drive contains the first CD ROM */
528 if (CX_reg(context) != drive) {
529 WARN("Request made doesn't match a CD ROM drive (%d/%d)\n", CX_reg(context), drive);
530 driver_request[4] |= 0x80;
531 driver_request[3] = 1; /* unknown unit */
532 return;
533 }
534
535 MSCDEX_Dump("Beg", driver_request, dorealmode);
536
537 /* set status to 0 */
538 PTR_AT(driver_request, 3, WORD) = 0;
539 CDROM_Audio_GetCDStatus(&wcda);
540
541 switch (driver_request[2]) {
542 case 3:
543 io_stru = (dorealmode) ?
544 DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(driver_request, 14, WORD), PTR_AT(driver_request, 16, WORD))) :
545 PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD));
546
547 TRACE(" --> IOCTL INPUT <%d>\n", io_stru[0]);
548 switch (io_stru[0]) {
549 #if 0
550 case 0: /* Get device Header */
551 {
552 static LPSTR ptr = 0;
553 if (ptr == 0) {
554 ptr = SEGPTR_ALLOC(22);
555 PTR_AT(ptr, 0, DWORD) = ~1; /* Next Device Driver */
556 PTR_AT(ptr, 4, WORD) = 0xC800; /* Device attributes */
557 PTR_AT(ptr, 6, WORD) = 0x1234; /* Pointer to device strategy routine: FIXME */
558 PTR_AT(ptr, 8, WORD) = 0x3142; /* Pointer to device interrupt routine: FIXME */
559 PTR_AT(ptr, 10, char) = 'W'; /* 8-byte character device name field */
560 PTR_AT(ptr, 11, char) = 'I';
561 PTR_AT(ptr, 12, char) = 'N';
562 PTR_AT(ptr, 13, char) = 'E';
563 PTR_AT(ptr, 14, char) = '_';
564 PTR_AT(ptr, 15, char) = 'C';
565 PTR_AT(ptr, 16, char) = 'D';
566 PTR_AT(ptr, 17, char) = '_';
567 PTR_AT(ptr, 18, WORD) = 0; /* Reserved (must be zero) */
568 PTR_AT(ptr, 20, BYTE) = 0; /* Drive letter (must be zero) */
569 PTR_AT(ptr, 21, BYTE) = 1; /* Number of units supported (one or more) FIXME*/
570 }
571 PTR_AT(io_stru, DWORD, 0) = SEGPTR_GET(ptr);
572 }
573 break;
574 #endif
575
576 case 1: /* location of head */
577 switch (io_stru[1]) {
578 case 0:
579 PTR_AT(io_stru, 2, DWORD) = wcda.dwCurFrame;
580 break;
581 case 1:
582 MSCDEX_StoreMSF(wcda.dwCurFrame, io_stru + 2);
583 break;
584 default:
585 ERR("CDRom-Driver: Unsupported addressing mode !!\n");
586 Error = 0x0c;
587 }
588 TRACE(" ----> HEAD LOCATION <%ld>\n", PTR_AT(io_stru, 2, DWORD));
589 break;
590
591 case 4: /* Audio channel info */
592 io_stru[1] = 0;
593 io_stru[2] = 0xff;
594 io_stru[3] = 1;
595 io_stru[4] = 0xff;
596 io_stru[5] = 2;
597 io_stru[6] = 0;
598 io_stru[7] = 3;
599 io_stru[8] = 0;
600 TRACE(" ----> AUDIO CHANNEL INFO\n");
601 break;
602
603 case 6: /* device status */
604 PTR_AT(io_stru, 1, DWORD) = 0x00000290;
605 /* 290 =>
606 * 1 Supports HSG and Red Book addressing modes
607 * 0 Supports audio channel manipulation
608 *
609 * 1 Supports prefetching requests
610 * 0 Reserved
611 * 0 No interleaving
612 * 1 Data read and plays audio/video tracks
613 *
614 * 0 Read only
615 * 0 Supports only cooked reading
616 * 0 Door locked
617 * 0 see below (Door closed/opened)
618 */
619 if (wcda.cdaMode == WINE_CDA_OPEN)
620 io_stru[1] |= 1;
621 TRACE(" ----> DEVICE STATUS <0x%08lx>\n", PTR_AT(io_stru, 1, DWORD));
622 break;
623
624 case 8: /* Volume size */
625 PTR_AT(io_stru, 1, DWORD) = wcda.dwLastFrame;
626 TRACE(" ----> VOLUME SIZE <%ld>\n", PTR_AT(io_stru, 1, DWORD));
627 break;
628
629 case 9: /* media changed ? */
630 /* answers don't know... -1/1 for yes/no would be better */
631 io_stru[1] = 0; /* FIXME? 1? */
632 TRACE(" ----> MEDIA CHANGED <%d>\n", io_stru[1]);
633 break;
634
635 case 10: /* audio disk info */
636 io_stru[1] = wcda.nFirstTrack; /* starting track of the disc */
637 io_stru[2] = wcda.nLastTrack; /* ending track */
638 MSCDEX_StoreMSF(wcda.dwLastFrame, io_stru + 3);
639
640 TRACE(" ----> AUDIO DISK INFO <%d-%d/%08lx>\n",
641 io_stru[1], io_stru[2], PTR_AT(io_stru, 3, DWORD));
642 break;
643
644 case 11: /* audio track info */
645 if (io_stru[1] >= wcda.nFirstTrack && io_stru[1] <= wcda.nLastTrack) {
646 int nt = io_stru[1] - wcda.nFirstTrack;
647 MSCDEX_StoreMSF(wcda.lpdwTrackPos[nt], io_stru + 2);
648 /* starting point if the track */
649 io_stru[6] = (wcda.lpbTrackFlags[nt] & 0xF0) >> 4;
650 } else {
651 PTR_AT(io_stru, 2, DWORD) = 0;
652 io_stru[6] = 0;
653 }
654 TRACE(" ----> AUDIO TRACK INFO[%d] = [%08lx:%d]\n",
655 io_stru[1], PTR_AT(io_stru, 2, DWORD), io_stru[6]);
656 break;
657
658 case 12: /* get Q-Channel info */
659 io_stru[1] = wcda.lpbTrackFlags[wcda.nCurTrack - 1];
660 io_stru[2] = wcda.nCurTrack;
661 io_stru[3] = 0; /* FIXME ?? */
662
663 /* why the heck did MS use another format for 0MSF information... sigh */
664 {
665 BYTE bTmp[4];
666
667 MSCDEX_StoreMSF(wcda.dwCurFrame - wcda.lpdwTrackPos[wcda.nCurTrack - 1], bTmp);
668 io_stru[ 4] = bTmp[2];
669 io_stru[ 5] = bTmp[1];
670 io_stru[ 6] = bTmp[0];
671 io_stru[ 7] = 0;
672
673 MSCDEX_StoreMSF(wcda.dwCurFrame, bTmp);
674 io_stru[ 8] = bTmp[2];
675 io_stru[ 9] = bTmp[1];
676 io_stru[10] = bTmp[0];
677 io_stru[11] = 0;
678 }
679 TRACE("Q-Channel info: Ctrl/adr=%02x TNO=%02x X=%02x rtt=%02x:%02x:%02x rtd=%02x:%02x:%02x (cf=%08lx, tp=%08lx)\n",
680 io_stru[ 1], io_stru[ 2], io_stru[ 3],
681 io_stru[ 4], io_stru[ 5], io_stru[ 6],
682 io_stru[ 8], io_stru[ 9], io_stru[10],
683 wcda.dwCurFrame, wcda.lpdwTrackPos[wcda.nCurTrack - 1]);
684 break;
685
686 case 15: /* Audio status info */
687 /* !!!! FIXME FIXME FIXME !! */
688 PTR_AT(io_stru, 1, WORD) = 2 | ((wcda.cdaMode == WINE_CDA_PAUSE) ? 1 : 0);
689 if (wcda.cdaMode == WINE_CDA_OPEN) {
690 PTR_AT(io_stru, 3, DWORD) = 0;
691 PTR_AT(io_stru, 7, DWORD) = 0;
692 } else {
693 PTR_AT(io_stru, 3, DWORD) = wcda.lpdwTrackPos[0];
694 PTR_AT(io_stru, 7, DWORD) = wcda.lpdwTrackPos[wcda.nTracks - 1];
695 }
696 TRACE("Audio status info: status=%04x startLoc=%ld endLoc=%ld\n",
697 PTR_AT(io_stru, 1, WORD), PTR_AT(io_stru, 3, DWORD), PTR_AT(io_stru, 7, DWORD));
698 break;
699
700 default:
701 FIXME("IOCTL INPUT: Unimplemented <%d>!!\n", io_stru[0]);
702 Error = 0x0c;
703 break;
704 }
705 break;
706
707 case 12:
708 io_stru = (dorealmode) ?
709 DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(driver_request, 14, WORD), PTR_AT(driver_request, 16, WORD))) :
710 PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD));
711
712 TRACE(" --> IOCTL OUTPUT <%d>\n", io_stru[0]);
713 switch (io_stru[0]) {
714 case 0: /* eject */
715 CDROM_SetDoor(&wcda, 1);
716 TRACE(" ----> EJECT\n");
717 break;
718 case 2: /* reset drive */
719 CDROM_Reset(&wcda);
720 TRACE(" ----> RESET\n");
721 break;
722 case 3: /* Audio Channel Control */
723 FIXME(" ----> AUDIO CHANNEL CONTROL (NIY)\n");
724 break;
725 case 5: /* close tray */
726 CDROM_SetDoor(&wcda, 0);
727 TRACE(" ----> CLOSE TRAY\n");
728 break;
729 default:
730 FIXME(" IOCTL OUTPUT: Unimplemented <%d>!!\n", io_stru[0]);
731 Error = 0x0c;
732 break;
733 }
734 break;
735
736 case 131: /* seek */
737 {
738 DWORD at;
739
740 at = PTR_AT(driver_request, 20, DWORD);
741
742 TRACE(" --> SEEK AUDIO mode :<0x%02X>, [%ld]\n",
743 (BYTE)driver_request[13], at);
744
745 switch (driver_request[13]) {
746 case 1: /* Red book addressing mode = 0:m:s:f */
747 /* FIXME : frame <=> msf conversion routines could be shared
748 * between mscdex and mcicda
749 */
750 at = LOBYTE(HIWORD(at)) * CDFRAMES_PERMIN +
751 HIBYTE(LOWORD(at)) * CDFRAMES_PERSEC +
752 LOBYTE(LOWORD(at));
753 /* fall thru */
754 case 0: /* HSG addressing mode */
755 CDROM_Audio_Seek(&wcda, at);
756 break;
757 default:
758 ERR("Unsupported address mode !!\n");
759 Error = 0x0c;
760 break;
761 }
762 }
763 break;
764
765 case 132: /* play */
766 {
767 DWORD beg, end;
768
769 beg = end = PTR_AT(driver_request, 14, DWORD);
770 end += PTR_AT(driver_request, 18, DWORD);
771
772 TRACE(" --> PLAY AUDIO mode :<0x%02X>, [%ld-%ld]\n",
773 (BYTE)driver_request[13], beg, end);
774
775 switch (driver_request[13]) {
776 case 1: /* Red book addressing mode = 0:m:s:f */
777 /* FIXME : frame <=> msf conversion routines could be shared
778 * between mscdex and mcicda
779 */
780 beg = LOBYTE(HIWORD(beg)) * CDFRAMES_PERMIN +
781 HIBYTE(LOWORD(beg)) * CDFRAMES_PERSEC +
782 LOBYTE(LOWORD(beg));
783 end = LOBYTE(HIWORD(end)) * CDFRAMES_PERMIN +
784 HIBYTE(LOWORD(end)) * CDFRAMES_PERSEC +
785 LOBYTE(LOWORD(end));
786 /* fall thru */
787 case 0: /* HSG addressing mode */
788 CDROM_Audio_Play(&wcda, beg, end);
789 break;
790 default:
791 ERR("Unsupported address mode !!\n");
792 Error = 0x0c;
793 break;
794 }
795 }
796 break;
797
798 case 133:
799 if (wcda.cdaMode == WINE_CDA_PLAY) {
800 CDROM_Audio_Pause(&wcda, 1);
801 TRACE(" --> STOP AUDIO (Paused)\n");
802 } else {
803 CDROM_Audio_Stop(&wcda);
804 TRACE(" --> STOP AUDIO (Stopped)\n");
805 }
806 break;
807
808 case 136:
809 TRACE(" --> RESUME AUDIO\n");
810 CDROM_Audio_Pause(&wcda, 0);
811 break;
812
813 default:
814 FIXME(" ioctl uninplemented <%d>\n", driver_request[2]);
815 Error = 0x0c;
816 }
817
818 /* setting error codes if any */
819 if (Error < 255) {
820 driver_request[4] |= 0x80;
821 driver_request[3] = Error;
822 }
823
824 /* setting status bits
825 * 3 == playing && done
826 * 1 == done
827 */
828 driver_request[4] |= (wcda.cdaMode == WINE_CDA_PLAY) ? 3 : 1;
829
830 MSCDEX_Dump("End", driver_request, dorealmode);
831 }
832 break;
833 default:
834 FIXME("Unimplemented MSCDEX function 0x%02X.\n", AL_reg(context));
835 break;
836 }
837 }
Windows API implementation