home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Jumpstart / Multimedia Microsoft Jumpstart Version 1.1a (Microsoft).BIN / develpmt / drivers / mscdex / testdrv / request.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-25  |  9.3 KB  |  419 lines
  1. /*
  2. ** TESTDRV
  3. **
  4. ** Device Driver Test for MSCDEX compatible CD-ROM
  5. **
  6. ** FILE: request.c
  7. ** jyg
  8. **
  9. **  Proper C calls for requests
  10. **
  11. **  Naming convention:
  12. **
  13. **  W DvRq <Cmd> <Subcmd>   W   = returns a word
  14. **              DvRq    = device request
  15. **              Cmd = command abbrev
  16. **              Subcmd  = sub command abbrev
  17. **  e.g. WDvRqIoiRaddr - device request, ioctl input subcommand,
  18. **              Return address of device header,
  19. **              returns the status word
  20. **
  21. **  Why so ugly?  Its an attempt at Hungarian
  22. **
  23. **  REQUIRES request.h
  24. **  HISTORY:
  25. **      10/01/90 Final (v1.0) -by- JYG
  26. **  Revised 12/06/91 Siddhartha Roy 
  27. */
  28.  
  29. #ifdef TESTDRV
  30. #include"test.h"
  31. #endif
  32.  
  33. #include"request.h"
  34.  
  35. /*
  36. ** Lowlevel routines whic ultimately call the driver
  37. ** Called by the logical routines in tests.c
  38. ** While adding a routine here follow the convention here
  39. */
  40.  
  41. WORD WDvRqInit(drv,endaddr,pBPB)
  42. Dev_List    *drv;
  43. BYTE far    *endaddr;
  44. BYTE far    *pBPB;
  45. {
  46.     Init_Hdr        Init;
  47.     register Init_Hdr   *req = &Init;
  48. #ifdef TESTDRV
  49.     extern WORD cwRequests;
  50.     cwRequests++;
  51. #endif
  52.  
  53.     Init.rqh.len    = sizeof(Init_Hdr);
  54.     Init.rqh.unit   = drv->sub_unit;
  55.     Init.rqh.cmd    = DVRQ_INIT;
  56.     Init.rqh.status = 0;
  57.  
  58.     Init.units  = 0;
  59.     Init.devno  = 0;
  60.  
  61.     send_req((ReadWriteL_Hdr far *) req, drv->dev_addr);
  62.  
  63.     endaddr = Init.endaddr;
  64.     pBPB    = Init.bpbarr;
  65.  
  66.     return (req->rqh.status);
  67. }
  68.  
  69.  
  70.  
  71. WORD WDvRqIoiRaddr(drv,pAddr)
  72. Dev_List    *drv;
  73. DWORD       *pAddr;
  74. {
  75.     Raddr_Rec       Raddr;
  76.     register Raddr_Rec  *req=&Raddr;
  77.     WORD            wStatus;
  78.  
  79.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_ret_addr,
  80.         sizeof(Raddr_Rec));
  81.     *pAddr = Raddr.addr;
  82.  
  83.     return (wStatus);
  84. }
  85.  
  86. WORD WDvRqIoiLocHead(drv,addrmode,drvhead)
  87. Dev_List    *drv;
  88. BYTE        addrmode;
  89. DWORD       *drvhead;
  90. {
  91.     LocHead_Rec     LocHead;
  92.     LocHead_Rec     *req = &LocHead;
  93.     WORD            wStatus;
  94.  
  95.     LocHead.addrmode = addrmode;
  96.  
  97.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_loc_head,
  98.         sizeof(LocHead_Rec));
  99.     *drvhead = LocHead.drvhead;
  100.     return (wStatus);
  101. }
  102.  
  103.  
  104. WORD WDvRqIoiSimple(drv,chCall)
  105. Dev_List    *drv;
  106. BYTE        chCall;
  107. {
  108.     BYTE Simple;
  109.     return ioctl(drv,&Simple,DVRQ_IOCTLI,chCall,sizeof(BYTE));
  110. }
  111. WORD WDvRqIooSimple(drv,chCall)
  112. Dev_List    *drv;
  113. BYTE        chCall;
  114. {
  115.     BYTE        Simple;
  116.     return ioctl(drv,&Simple,DVRQ_IOCTLO,chCall,sizeof(BYTE));
  117. }
  118.  
  119.  
  120. WORD WDvRqIoiDevStat(drv,pParams)
  121. Dev_List    *drv;
  122. DWORD       *pParams;
  123. {
  124.     DevStat_Rec     DevStat;
  125.     DevStat_Rec     *req = &DevStat;
  126.     WORD            wStatus;
  127.  
  128.  
  129.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_dev_status,
  130.         sizeof(DevStat_Rec));
  131.     *pParams = DevStat.params;
  132.  
  133.     return (wStatus);
  134. }
  135.  
  136. WORD WDvRqIoiSectSize(drv,rdmode,wSize)
  137. Dev_List    *drv;
  138. BYTE        rdmode;
  139. WORD        *wSize;
  140. {
  141.     SectSize_Rec        SectSize;
  142.     SectSize_Rec        *req = &SectSize;
  143.     WORD            wStatus;
  144.  
  145.  
  146.     SectSize.rmode = rdmode;
  147.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_ret_sectsize,
  148.         sizeof(SectSize_Rec));
  149.     *wSize = SectSize.sectsize;
  150.     return (wStatus);
  151. }
  152.  
  153. WORD WDvRqIoiVolSize(drv,wSize)
  154. Dev_List    *drv;
  155. DWORD       *wSize;
  156. {
  157.     VolSize_Rec     VolSize;
  158.     VolSize_Rec     *req = &VolSize;
  159.     WORD            wStatus;
  160.  
  161.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_ret_volsize,
  162.         sizeof(VolSize_Rec));
  163.     *wSize = VolSize.volsize;
  164.  
  165.     return (wStatus);
  166. }
  167.  
  168. WORD WDvRqIoiMedChng(drv,pMbyte)
  169. Dev_List    *drv;
  170. char        *pMbyte;
  171. {
  172.     MedChng_Rec     MedChng;
  173.     MedChng_Rec     *req = &MedChng;
  174.     WORD            wStatus;
  175.  
  176.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_media_changed,
  177.         sizeof(MedChng_Rec));
  178.     *pMbyte = MedChng.medbyte;
  179.  
  180.     return (wStatus);
  181. }
  182.  
  183.  
  184. WORD WDvRqIoiTnoInfo(drv,tno,trackinf)
  185. Dev_List    *drv;
  186. BYTE        tno;
  187. TnoInfo_Rec *trackinf;
  188. {
  189.     WORD            wStatus;
  190.  
  191.     trackinf->tno = tno;
  192.     wStatus = ioctl(drv,(BYTE *) trackinf,DVRQ_IOCTLI,IOI_audio_trk_inf,
  193.         sizeof(TnoInfo_Rec));
  194.  
  195.     return wStatus;
  196. }
  197.  
  198. WORD WDvRqIoiSubChInfo(drv,frameAddr,xfer,nosects)
  199. Dev_List    *drv;
  200. DWORD       frameAddr;
  201. BYTE _far   *xfer;
  202. DWORD       nosects;
  203. {
  204.     SubChanInfo_Rec     SubChanInfo;
  205.     SubChanInfo_Rec     *req = &SubChanInfo;
  206.     WORD            wStatus;
  207.  
  208.     SubChanInfo.start_tno   = frameAddr;
  209.     SubChanInfo.xfer    = (BYTE far *) xfer;
  210.     SubChanInfo.nsect   = nosects;
  211.  
  212.     wStatus = ioctl(drv,(BYTE *)req,DVRQ_IOCTLI,IOI_audio_subinfo,
  213.         sizeof(SubChanInfo_Rec));
  214.  
  215.     return (wStatus);
  216.  
  217. }
  218.  
  219. WORD WDvRqIooEject(drv)
  220. Dev_List    *drv;
  221. {
  222.     BYTE        code;
  223.     return ioctl(drv,&code,DVRQ_IOCTLO,IOO_eject_disc,sizeof(BYTE));
  224. }
  225.  
  226. WORD WDvRqIooLockDoor(drv,fcn)
  227. Dev_List    *drv;
  228. BYTE        fcn;
  229. {
  230.     LockDoor_Rec        LockDoor;
  231.     LockDoor_Rec        *req = &LockDoor;
  232.     LockDoor.fcn = fcn;
  233.     return ioctl(drv,(BYTE *)req,DVRQ_IOCTLO,IOO_lock_door,sizeof(LockDoor));
  234. }
  235.  
  236. WORD WDvRqIooReset(drv)
  237. Dev_List    *drv;
  238. {
  239.     BYTE        reset;
  240.     return ioctl(drv,&reset,DVRQ_IOCTLO,IOO_reset_drv,sizeof(BYTE));
  241. }
  242.  
  243. WORD WDvRqIooDrvBytes(drv)
  244. Dev_List    *drv;
  245. {
  246.     BYTE        DrvBytes;
  247.     return ioctl(drv,&DrvBytes,DVRQ_IOCTLO,IOO_wr_drv_bytes,
  248.         sizeof(BYTE));
  249. }
  250. WORD WDvRqIooCloseTray(drv)
  251. Dev_List    *drv;
  252. {
  253.     BYTE        CloseTray;
  254.     return ioctl(drv,&CloseTray,DVRQ_IOCTLO,IOO_close_tray,sizeof(BYTE));
  255. }
  256.  
  257. WORD WDvRqReadWriteL(drv,cmd,xfer,start,num,addrmode,mode,ilsize,ilskip)
  258. Dev_List    *drv;
  259. BYTE        cmd;
  260. BYTE far    *xfer;
  261. DWORD       start;
  262. WORD        num;
  263. BYTE        addrmode;
  264. BYTE        mode;
  265. BYTE        ilsize;
  266. BYTE        ilskip;
  267. {
  268.     ReadWriteL_Hdr      Read_Rec;
  269.     register ReadWriteL_Hdr far *req = &Read_Rec;
  270. #ifdef TESTDRV
  271.     extern WORD cwRequests;
  272.     cwRequests++;
  273. #endif
  274.  
  275.     req->rqh.len        = sizeof(ReadWriteL_Hdr);
  276.     req->rqh.unit       = drv->sub_unit;
  277.     req->rqh.cmd        = (BYTE) (cmd);
  278.     req->rqh.status     = 0;
  279.  
  280.     req->addrmd     = addrmode;
  281.     req->xfer       = (BYTE far *) xfer;
  282.     req->nsects     = num;
  283.     req->start      = start;
  284.     req->mode       = mode;
  285.     req->ilskip     = ilskip;
  286.     req->ilsize     = ilsize;
  287.  
  288.     send_req((ReadWriteL_Hdr far *) req, drv->dev_addr);
  289.     return (req->rqh.status);
  290. }
  291.  
  292. /*
  293. ** Seek Request
  294. */
  295.  
  296. WORD WDvRqSeek(drv,start,mode)
  297. Dev_List    *drv;
  298. DWORD       start;
  299. BYTE        mode;
  300. {
  301.     SeekReq_Hdr     Seek_Rec;
  302.     SeekReq_Hdr far     *req = &Seek_Rec;
  303. #ifdef TESTDRV
  304.     extern WORD cwRequests;
  305.     cwRequests++;
  306. #endif
  307.  
  308.     req->rqh.len        = sizeof(SeekReq_Hdr);
  309.     req->rqh.unit       = drv->sub_unit;
  310.     req->rqh.cmd        = (BYTE) (DVRQ_SEEK);
  311.     req->rqh.status     = 0;
  312.  
  313.     req->addrmd     = mode;
  314.     req->start      = start;
  315.     req->zero       = (DWORD) 0;
  316.     req->nsects     = 0;
  317.     cwRequests++;
  318.     send_req((ReadWriteL_Hdr far *) req, drv->dev_addr);
  319.     return (req->rqh.status);   // Return Error Status
  320. }
  321.  
  322.  
  323. /*
  324. ** Play Request
  325. */
  326.  
  327. WORD WDvRqPlay(drv,start,num,mode)
  328. Dev_List    *drv;
  329. DWORD       start;
  330. DWORD       num;
  331. BYTE        mode;
  332. {
  333.     PlayReq_Hdr         Play_Rec;
  334.     register PlayReq_Hdr far    *req = &Play_Rec;
  335. #ifdef TESTDRV
  336.     extern WORD cwRequests;
  337.     cwRequests++;
  338. #endif
  339.  
  340.     req->rqh.len        = sizeof(PlayReq_Hdr);
  341.     req->rqh.unit       = drv->sub_unit;
  342.     req->rqh.cmd        = (BYTE) (DVRQ_PLAY);
  343.     req->rqh.status     = 0;
  344.  
  345.     req->addrmd     = mode;
  346.     req->start      = start;
  347.     req->num        = num;
  348.  
  349.     send_req((ReadWriteL_Hdr far *) req, drv->dev_addr);
  350.     return (req->rqh.status);   // Return Error Status
  351. }
  352.  
  353. /*
  354. ** Simple Request:
  355. **  Differs only by the command field in the Request Header
  356. */
  357.  
  358. WORD WDvRqSimple(drv,cmd)
  359. Dev_List    *drv;
  360. BYTE        cmd;
  361. {
  362.     Request_Hdr         Request_Rec;
  363.     register Request_Hdr        *req = &Request_Rec;
  364. #ifdef TESTDRV
  365.     extern WORD cwRequests;
  366.     cwRequests++;
  367. #endif
  368.  
  369.     req->len        = sizeof(Request_Hdr);
  370.     req->unit       = drv->sub_unit;
  371.     req->cmd        = (BYTE)(cmd);
  372.     req->status     = 0;
  373.     cwRequests++;
  374.     send_req((ReadWriteL_Hdr far *) req, drv->dev_addr);
  375.     return (req->status);
  376. }
  377.  
  378.  
  379. /* ioctl() -
  380. **
  381. ** DESCRIPTION
  382. **  Sends an IOCTL request to the device driver in drv. The
  383. **  ioctl command is cmd and the ioctl cmd length is cmdlen.
  384. **  The buffer for the command is pointed to by xbuf.
  385. **  Returns the status word
  386. */
  387.  
  388.  
  389. WORD    ioctl(drv, xbuf, iocmd, cmd, cmdlen)
  390. Dev_List    *drv;
  391. BYTE        *xbuf;
  392. BYTE        iocmd;
  393. BYTE        cmd;
  394. BYTE        cmdlen;
  395. {
  396.     Ioctl_Hdr       Ioctl_Rec;
  397.     register Ioctl_Hdr  *io = &Ioctl_Rec;
  398. #ifdef TESTDRV
  399.     extern WORD cwRequests;
  400.     cwRequests++;
  401. #endif
  402.  
  403.     io->rqh.len     = sizeof(Ioctl_Hdr);
  404.     io->rqh.unit    = drv->sub_unit;
  405.     io->rqh.cmd     = iocmd;
  406.     io->rqh.status  = 0;
  407.  
  408.     io->media       = 0;
  409.     io->xfer        = (char far *) xbuf;
  410.     *xbuf           = cmd; // First byte of Control Block determines sub command
  411.     io->nbytes      = cmdlen;
  412.     io->sector      = 0;
  413.     io->valid       = 0;
  414.  
  415.     send_req((ReadWriteL_Hdr far *) io, drv->dev_addr);
  416.     return (io->rqh.status);
  417.  
  418. }
  419.