开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
DSK.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：19k
源码类别：

操作系统开发

开发平台：

DOS

DSK.C：源码内容
  1. /****************************************************************/
  2. /* */
  3. /*       dsk.c */
  4. /* */
  5. /* Copyright (c) 1995 */
  6. /* Pasquale J. Villani */
  7. /* All Rights Reserved */
  8. /* */
  9. /* This file is part of DOS-C. */
  10. /* */
  11. /* DOS-C is free software; you can redistribute it and/or */
  12. /* modify it under the terms of the GNU General Public License */
  13. /* as published by the Free Software Foundation; either version */
  14. /* 2, or (at your option) any later version. */
  15. /* */
  16. /* DOS-C is distributed in the hope that it will be useful, but */
  17. /* WITHOUT ANY WARRANTY; without even the implied warranty of */
  18. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See */
  19. /* the GNU General Public License for more details. */
  20. /* */
  21. /* You should have received a copy of the GNU General Public */
  22. /* License along with DOS-C; see the file COPYING.  If not, */
  23. /* write to the Free Software Foundation, 675 Mass Ave, */
  24. /* Cambridge, MA 02139, USA. */
  25. /****************************************************************/
  27. #include "../../hdr/portab.h"
  28. #include "globals.h"
  30. /* $Logfile:   C:/dos-c/src/kernel/dsk.c_v  $ */
  31. #ifdef VERSION_STRINGS
  32. static BYTE *dskRcsId = "$Header:   C:/dos-c/src/kernel/dsk.c_v   1.6   04 Jan 1998 23:15:16   patv  $";
  33. #endif
  35. /* $Log:   C:/dos-c/src/kernel/dsk.c_v  $
  36.  * 
  37.  *    Rev 1.6   04 Jan 1998 23:15:16   patv
  38.  * Changed Log for strip utility
  39.  * 
  40.  *    Rev 1.5   10 Jan 1997  5:41:48   patv
  41.  * Modified for extended partition support
  42.  *
  43.  *    Rev 1.4   29 May 1996 21:03:32   patv
  44.  * bug fixes for v0.91a
  45.  *
  46.  *    Rev 1.3   19 Feb 1996  3:21:36   patv
  47.  * Added NLS, int2f and config.sys processing
  48.  *
  49.  *    Rev 1.2   01 Sep 1995 17:54:18   patv
  50.  * First GPL release.
  51.  *
  52.  *    Rev 1.1   30 Jul 1995 20:52:00   patv
  53.  * Eliminated version strings in ipl
  54.  *
  55.  *    Rev 1.0   02 Jul 1995  8:32:42   patv
  56.  * Initial revision.
  57.  */
  58. /* $EndLog$ */
  60. #ifdef PROTO
  61. BOOL fl_reset(VOID);
  62. COUNT fl_rd_status(WORD);
  63. COUNT fl_read(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  64. COUNT fl_write(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  65. BOOL fl_verify(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  66. BOOL fl_format(WORD, BYTE FAR *);
  67. #else
  68. BOOL fl_reset();
  69. COUNT fl_rd_status();
  70. COUNT fl_read();
  71. COUNT fl_write();
  72. BOOL fl_verify();
  73. BOOL fl_format();
  74. #endif
  76. #define NDEV 8 /* only one for demo */
  77. #define SEC_SIZE 512 /* size of sector in bytes */
  78. #define N_RETRY 5 /* number of retries permitted */
  79. #define NENTRY 25 /* total size of dispatch table */
  81. union
  82. {
  83. BYTE bytes[2 * SEC_SIZE];
  84. boot boot_sector;
  85. } buffer;
  87. static struct media_info
  88. {
  89. ULONG mi_size; /* physical sector count */
  90. UWORD mi_heads; /* number of heads (sides) */
  91. UWORD mi_cyls; /* number of cyl/drive */
  92. UWORD mi_sectors; /* number of sectors/cyl */
  93. ULONG mi_offset; /* relative partition offset */
  94.         BYTE    mi_drive;               /* BIOS drive number            */
  95.         COUNT   mi_partidx;             /* Index to partition array     */
  96. };
  98. static struct media_info miarray[NDEV]; /* Internal media info structs  */
  99. static bpb bpbarray[NDEV];              /* BIOS parameter blocks        */
  100. static bpb *bpbptrs[NDEV];              /* pointers to bpbs             */
  102. #define N_PART 4                        /* number of partitions per
  103.                                            table partition              */
  105. static WORD head, track, sector, ret;   /* globals for blockio          */
  106. static WORD count;
  107. static COUNT nUnits;                    /* number of returned units     */
  108. static COUNT nPartitions;               /* number of DOS partitions     */
  110. #define PARTOFF 0x1be
  112. static struct
  113. {
  114.         BYTE    peDrive;                /* BIOS drive number            */
  115. BYTE peBootable;
  116. BYTE peBeginHead;
  117. BYTE peBeginSector;
  118. UWORD peBeginCylinder;
  119. BYTE peFileSystem;
  120. BYTE peEndHead;
  121. BYTE peEndSector;
  122. UWORD peEndCylinder;
  123. LONG peStartSector;
  124. LONG peSectors;
  125.         LONG    peAbsStart;             /* Absolute sector start        */
  126. } dos_partition[NDEV - 2];
  129. #ifdef PROTO
  130. WORD init(rqptr), mediachk(rqptr), bldbpb(rqptr), blockio(rqptr), blk_error(rqptr);
  131. COUNT ltop(WORD *, WORD *, WORD *, COUNT, COUNT, LONG, byteptr);
  132. WORD dskerr(COUNT);
  133. COUNT processtable(COUNT ptDrive, BYTE ptHead, UWORD ptCylinder, BYTE ptSector, LONG ptAccuOff);
  134. #else
  135. WORD init(), mediachk(), bldbpb(), blockio(), blk_error();
  136. WORD dskerr();
  137. COUNT processtable();
  138. #endif
  140. /* */
  141. /* the function dispatch table */
  142. /* */
  144. #ifdef PROTO
  145. static WORD (*dispatch[NENTRY]) (rqptr) =
  146. #else
  147. static WORD (*dispatch[NENTRY]) () =
  148. #endif
  149. {
  150. init, /* Initialize */
  151. mediachk, /* Media Check */
  152. bldbpb, /* Build BPB */
  153. blk_error, /* Ioctl In */
  154. blockio, /* Input (Read) */
  155. blk_error, /* Non-destructive Read */
  156. blk_error, /* Input Status */
  157. blk_error, /* Input Flush */
  158. blockio, /* Output (Write) */
  159. blockio, /* Output with verify */
  160. blk_error, /* Output Status */
  161. blk_error, /* Output Flush */
  162. blk_error, /* Ioctl Out */
  163. blk_error, /* Device Open */
  164. blk_error, /* Device Close */
  165. blk_error, /* Removable Media */
  166. blk_error, /* Output till busy */
  167. blk_error, /* undefined */
  168. blk_error, /* undefined */
  169. blk_error, /* Generic Ioctl */
  170. blk_error, /* undefined */
  171. blk_error, /* undefined */
  172. blk_error, /* undefined */
  173. blk_error, /* Get Logical Device */
  174. blk_error /* Set Logical Device */
  175. };
  177. #define SIZEOF_PARTENT 16
  179. #define FAT12 0x01
  180. #define FAT16SMALL 0x04
  181. #define EXTENDED 0x05
  182. #define FAT16LARGE 0x06
  184. #define hd(x) ((x) & 0x80)
  186. COUNT
  187. processtable (COUNT ptDrive, BYTE ptHead, UWORD ptCylinder,
  188.               BYTE ptSector, LONG ptAccuOff)
  189. {
  190.         struct                          /* Temporary partition table    */
  191.         {
  192.          BYTE peBootable;
  193.         BYTE peBeginHead;
  194.                 BYTE peBeginSector;
  195.                 UWORD   peBeginCylinder;
  196.         BYTE peFileSystem;
  197.         BYTE peEndHead;
  198.                 BYTE peEndSector;
  199.         UWORD peEndCylinder;
  200.         LONG peStartSector;
  201.         LONG peSectors;
  202.         } temp_part[N_PART];
  204. REG retry = N_RETRY;
  205.         UBYTE packed_byte, pb1;
  206.         COUNT Part;
  208.         /* Read partition table                         */
  209. do
  210. {
  211. ret = fl_read ((WORD)ptDrive, (WORD)ptHead, (WORD)ptCylinder,
  212.                                (WORD)ptSector, (WORD)1, (byteptr)&buffer);
  213. } while (ret != 0 && --retry > 0);
  214. if(ret != 0)
  215. return FALSE;
  217.         /* Read each partition into temporary array     */
  218.         for (Part = 0; Part < N_PART; Part++)
  219.         {
  220.         REG BYTE *p =
  221.                     (BYTE *)&buffer.bytes[PARTOFF + (Part * SIZEOF_PARTENT)];
  223.                 getbyte((VOID *)p, &temp_part[Part].peBootable);
  224.         ++p;
  225.         getbyte((VOID *)p, &temp_part[Part].peBeginHead);
  226.         ++p;
  227.         getbyte((VOID *)p, &packed_byte);
  228.         temp_part[Part].peBeginSector = packed_byte & 0x3f;
  229.         ++p;
  230.         getbyte((VOID *)p, &pb1);
  231.         ++p;
  232.         temp_part[Part].peBeginCylinder = pb1 + ((UWORD)(0xc0 & packed_byte) << 2);
  233.         getbyte((VOID *)p, &temp_part[Part].peFileSystem);
  234.         ++p;
  235.         getbyte((VOID *)p, &temp_part[Part].peEndHead);
  236.         ++p;
  237.         getbyte((VOID *)p, &packed_byte);
  238.         temp_part[Part].peEndSector = packed_byte & 0x3f;
  239.         ++p;
  240.         getbyte((VOID *)p, &pb1);
  241.         ++p;
  242.         temp_part[Part].peEndCylinder = pb1 + ((UWORD)(0xc0 & packed_byte) << 2);
  243.         getlong((VOID *)p, &temp_part[Part].peStartSector);
  244.         p += sizeof(LONG);
  245.         getlong((VOID *)p, &temp_part[Part].peSectors);
  246.         };
  248.         /* Walk through the table, add DOS partitions to global
  249.            array and process extended partitions         */
  250.         for (Part = 0; Part < N_PART && nUnits < NDEV; Part++)
  251.         {
  252.                 if (temp_part[Part].peFileSystem == FAT12 ||
  253.                     temp_part[Part].peFileSystem == FAT16SMALL ||
  254.                     temp_part[Part].peFileSystem == FAT16LARGE)
  255.                 {
  256.                         miarray[nUnits].mi_offset =
  257.                                temp_part[Part].peStartSector + ptAccuOff;
  258.                         miarray[nUnits].mi_drive = ptDrive;
  259.                         miarray[nUnits].mi_partidx = nPartitions;
  260.                         nUnits++;
  262.                         dos_partition[nPartitions].peDrive = ptDrive;
  263.                         dos_partition[nPartitions].peBootable =
  264.                                temp_part[Part].peBootable;
  265.                         dos_partition[nPartitions].peBeginHead =
  266.                                temp_part[Part].peBeginHead;
  267.                         dos_partition[nPartitions].peBeginSector =
  268.                                temp_part[Part].peBeginSector;
  269.                         dos_partition[nPartitions].peBeginCylinder =
  270.                                temp_part[Part].peBeginCylinder;
  271.                         dos_partition[nPartitions].peFileSystem =
  272.                                temp_part[Part].peFileSystem;
  273.                         dos_partition[nPartitions].peEndHead =
  274.                                temp_part[Part].peEndHead;
  275.                         dos_partition[nPartitions].peEndSector =
  276.                                temp_part[Part].peEndSector;
  277.                         dos_partition[nPartitions].peEndCylinder =
  278.                                temp_part[Part].peEndCylinder;
  279.                         dos_partition[nPartitions].peStartSector =
  280.                                temp_part[Part].peStartSector;
  281.                         dos_partition[nPartitions].peSectors =
  282.                                temp_part[Part].peSectors;
  283.                         dos_partition[nPartitions].peAbsStart =
  284.                                temp_part[Part].peStartSector + ptAccuOff;
  285.                         nPartitions++;
  286.                 }
  287.                 else if (temp_part[Part].peFileSystem == EXTENDED)
  288.                 {
  289.                         /* call again to process extended part table */
  290.                         processtable (ptDrive,
  291.                                       temp_part[Part].peBeginHead,
  292.                                       temp_part[Part].peBeginCylinder,
  293.                                       temp_part[Part].peBeginSector,
  294.                                       temp_part[Part].peStartSector + ptAccuOff);
  295.                 };
  296.         };
  297.         return TRUE;
  298. }
  301. COUNT
  302. blk_driver (rqptr rp)
  303. {
  304. if(rp -> r_unit >= nUnits && rp-> r_command != C_INIT)
  305. return failure(E_UNIT);
  306. if(rp -> r_command > NENTRY)
  307. {
  308. return failure(E_FAILURE); /* general failure */
  309. }
  310. else
  311. return ((*dispatch[rp -> r_command])(rp));
  312. }
  315. static WORD
  316. init (rqptr rp)
  317. {
  318. COUNT HardDrive, Unit;
  320. /* Reset the drives */
  321. fl_reset();
  323.         /* Initial number of disk units                                 */
  324. nUnits = 2;
  325.         /* Initial number of DOS partitions                             */
  326.         nPartitions = 0;
  328.         /* Setup media info and BPBs arrays                             */
  329.         for (Unit = 0; Unit < NDEV; Unit++)
  330.         {
  331.                 miarray[Unit].mi_size = 720l;
  332.                 miarray[Unit].mi_heads = 2;
  333.                 miarray[Unit].mi_cyls = 40;
  334.                 miarray[Unit].mi_sectors = 9;
  335.                 miarray[Unit].mi_offset = 0l;
  336.                 miarray[Unit].mi_drive = Unit;
  338.                 bpbarray[Unit].bpb_nbyte = SEC_SIZE;
  339.                 bpbarray[Unit].bpb_nsector = 2;
  340.                 bpbarray[Unit].bpb_nreserved = 1;
  341.                 bpbarray[Unit].bpb_nfat = 2;
  342.                 bpbarray[Unit].bpb_ndirent = 112;
  343.                 bpbarray[Unit].bpb_nsize = 720l;
  344.                 bpbarray[Unit].bpb_mdesc = 0xfd;
  345.                 bpbarray[Unit].bpb_nfsect = 2;
  347.                 bpbptrs[Unit] = &bpbarray[Unit];
  348.         };
  350. for(HardDrive = 0; HardDrive <= 0; HardDrive++) /* only one hard drive for now */
  351. {
  352.                 /* Process primary partition table                      */
  353.                 if (!processtable ((HardDrive | 0x80), 0, 0l, 1, 0l))
  354.                    /* Exit if no hard drive                             */
  355.                    break;
  356.         };
  358. rp -> r_nunits = nUnits;
  359. rp -> r_bpbptr = bpbptrs;
  360.         rp -> r_endaddr = device_end();
  361. return S_DONE;
  362. }
  365. static WORD
  366. mediachk (rqptr rp)
  367. {
  368. if(hd(miarray[rp -> r_unit].mi_drive))
  369. rp -> r_mcretcode = M_NOT_CHANGED;
  370. else
  371. rp -> r_mcretcode = tdelay((LONG)37) ? M_DONT_KNOW : M_NOT_CHANGED;
  372. return S_DONE;
  373. }
  376. static WORD
  377. bldbpb (rqptr rp)
  378. {
  379. REG retry = N_RETRY;
  380. ULONG count;
  381. byteptr trans;
  382. WORD local_word;
  384. if(hd(miarray[rp -> r_unit].mi_drive))
  385. {
  386.                 COUNT partidx = miarray[rp -> r_unit].mi_partidx;
  387. head = dos_partition[partidx].peBeginHead;
  388. sector = dos_partition[partidx].peBeginSector;
  389. track = dos_partition[partidx].peBeginCylinder;
  390. }
  391. else
  392. {
  393. head = 0;
  394. sector = 1;
  395. track = 0;
  396. }
  398. do
  399. {
  400. ret = fl_read((WORD)miarray[rp -> r_unit].mi_drive,
  401.                       (WORD)head, (WORD)track, (WORD)sector, (WORD)1, (byteptr)&buffer);
  402. } while (ret != 0 && --retry > 0);
  403. if(ret != 0)
  404. return(dskerr(ret));
  406. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NBYTE]), &bpbarray[rp -> r_unit].bpb_nbyte);
  407. getbyte(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NSECTOR]), &bpbarray[rp -> r_unit].bpb_nsector);
  408. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NRESERVED]), &bpbarray[rp -> r_unit].bpb_nreserved);
  409. getbyte(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NFAT]), &bpbarray[rp -> r_unit].bpb_nfat);
  410. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NDIRENT]), &bpbarray[rp -> r_unit].bpb_ndirent);
  411. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NSIZE]), &bpbarray[rp -> r_unit].bpb_nsize);
  412. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NSIZE]), &bpbarray[rp -> r_unit].bpb_nsize);
  413. getbyte(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_MDESC]), &bpbarray[rp -> r_unit].bpb_mdesc);
  414. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NFSECT]), &bpbarray[rp -> r_unit].bpb_nfsect);
  415. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NSECS]), &bpbarray[rp -> r_unit].bpb_nsecs);
  416. getword(&((((BYTE *)&buffer.bytes[BT_BPB]))[BPB_NHEADS]), &bpbarray[rp -> r_unit].bpb_nheads);
  417. getlong(&((((BYTE *)&buffer.bytes[BT_BPB])[BPB_HIDDEN])), &bpbarray[rp -> r_unit].bpb_hidden);
  418. getlong(&((((BYTE *)&buffer.bytes[BT_BPB])[BPB_HUGE])), &bpbarray[rp -> r_unit].bpb_huge);
  419. #ifdef DSK_DEBUG
  420. printf("BPB_NBYTE     = %04xn", bpbarray[rp -> r_unit].bpb_nbyte);
  421. printf("BPB_NSECTOR   = %02xn", bpbarray[rp -> r_unit].bpb_nsector);
  422. printf("BPB_NRESERVED = %04xn", bpbarray[rp -> r_unit].bpb_nreserved);
  423. printf("BPB_NFAT      = %02xn", bpbarray[rp -> r_unit].bpb_nfat);
  424. printf("BPB_NDIRENT   = %04xn", bpbarray[rp -> r_unit].bpb_ndirent);
  425. printf("BPB_NSIZE     = %04xn", bpbarray[rp -> r_unit].bpb_nsize);
  426. printf("BPB_MDESC     = %02xn", bpbarray[rp -> r_unit].bpb_mdesc);
  427. printf("BPB_NFSECT    = %04xn", bpbarray[rp -> r_unit].bpb_nfsect);
  428. #endif
  429. rp -> r_bpptr = &bpbarray[rp -> r_unit];
  430. count = miarray[rp -> r_unit].mi_size =
  431.  bpbarray[rp -> r_unit].bpb_nsize == 0 ?
  432.   bpbarray[rp -> r_unit].bpb_huge :
  433.   bpbarray[rp -> r_unit].bpb_nsize;
  434. getword((&(((BYTE *)&buffer.bytes[BT_BPB])[BPB_NHEADS])), &miarray[rp -> r_unit].mi_heads);
  435. head = miarray[rp -> r_unit].mi_heads;
  436. getword((&(((BYTE *)&buffer.bytes[BT_BPB])[BPB_NSECS])), &miarray[rp -> r_unit].mi_sectors);
  437. if(miarray[rp -> r_unit].mi_size == 0)
  438. getlong(&((((BYTE *)&buffer.bytes[BT_BPB])[BPB_HUGE])), &miarray[rp -> r_unit].mi_size);
  439. sector = miarray[rp -> r_unit].mi_sectors;
  440. if(head == 0 || sector == 0)
  441. {
  442. tmark();
  443. return failure(E_FAILURE);
  444. }
  445. miarray[rp -> r_unit].mi_cyls = count / (head * sector);
  446. tmark();
  447. #ifdef DSK_DEBUG
  448. printf("BPB_NSECS     = %04xn", sector);
  449. printf("BPB_NHEADS    = %04xn", head);
  450. printf("BPB_HIDDEN    = %08lxn", bpbarray[rp -> r_unit].bpb_hidden);
  451. printf("BPB_HUGE      = %08lxn", bpbarray[rp -> r_unit].bpb_huge);
  452. #endif
  453. return S_DONE;
  454. }
  456. static WORD 
  457. blockio (rqptr rp)
  458. {
  459. REG retry = N_RETRY, remaining;
  460. UWORD cmd, total;
  461. ULONG start;
  462. byteptr trans;
  464. cmd = rp -> r_command;
  465. total = 0;
  466. trans = rp -> r_trans;
  467. tmark();
  468. for
  469. (
  470. remaining = rp -> r_count,
  471.  start = (rp -> r_start != HUGECOUNT ? rp -> r_start : rp -> r_huge)
  472.   + miarray[rp -> r_unit].mi_offset;
  473. remaining > 0;
  474. remaining -= count, trans += count * SEC_SIZE, start += count
  475. )
  476. {
  477. if(ltop(&track, &sector, &head,  rp -> r_unit, 1, start, trans) != 1)
  478. {
  479. /* printf("split sector at 0x%lx", trans);*/
  480. }
  481. count = ltop(&track, &sector, &head,  rp -> r_unit, remaining, start, trans);
  482. total += count;
  483. do
  484. {
  485. switch(cmd)
  486. {
  487. case C_INPUT:
  488. ret = fl_read((WORD)miarray[rp -> r_unit].mi_drive, (WORD)head, (WORD)track, (WORD)sector, (WORD)count, trans);
  489. break;
  491. case C_OUTPUT:
  492. case C_OUTVFY:
  493. ret = fl_write((WORD)miarray[rp -> r_unit].mi_drive, (WORD)head, (WORD)track, (WORD)sector, (WORD)count, trans);
  494. break;
  496. default:
  497. return failure(E_FAILURE);
  498. }
  499. } while (ret != 0 && --retry > 0);
  500. if(ret != 0)
  501. {
  502. rp -> r_count = 0;
  503. return dskerr(ret);
  504. }
  505. if(cmd == C_OUTVFY)
  506. {
  507. ret = fl_verify((WORD)miarray[rp -> r_unit].mi_drive, (WORD)head, (WORD)track, (WORD)sector, (WORD)count, rp -> r_trans);
  508. if(ret != 0)
  509. {
  510. rp -> r_count = 0;
  511. return dskerr(ret);
  512. }
  513. }
  514. }
  515. rp -> r_count = total;
  516. return S_DONE;
  517. }
  519. static WORD
  520. blk_error (rqptr rp)
  521. {
  522. rp -> r_count = 0;
  523. return failure(E_FAILURE); /* general failure */
  524. }
  528. static WORD
  529. dskerr (COUNT code)
  530. {
  531. /* printf("diskette error:nhead = %dntrack = %dnsector = %dncount = %dn",
  532. head, track, sector, count);*/
  533. switch(code & 0x03)
  534. {
  535. case 1: /* invalid command - general failure */
  536. if(code & 0x08)
  537. return(E_FAILURE);
  538. else
  539. return failure(E_CMD);
  541. case 2: /* address mark not found - general  failure */
  542. return failure(E_FAILURE);
  544. case 3: /* write protect */
  545. return failure(E_WRPRT);
  547. default:
  548. if(code & 0x80) /* time-out */
  549. return failure(E_NOTRDY);
  550. else if(code & 0x40) /* seek error */
  551. return failure(E_SEEK);
  552. else if(code & 0x10) /* CRC error */
  553. return failure(E_CRC);
  554. else if(code & 0x04)
  555. return failure(E_NOTFND);
  556. else
  557. return failure(E_FAILURE);
  558. }
  559. }
  561. /* */
  562. /* Do logical block number to physical head/track/sector mapping */
  563. /* */
  564. static COUNT
  565. ltop (WORD *trackp, WORD *sectorp, WORD *headp, REG COUNT unit, COUNT count, LONG strt_sect, byteptr strt_addr)
  566. {
  567. #ifdef I86
  568. ULONG ltemp;
  569. #endif
  570. REG ls, ps;
  572. #ifdef I86
  573. /* Adjust for segmented architecture */
  574. ltemp = (((ULONG)mk_segment(strt_addr) << 4) + mk_offset(strt_addr)) & 0xffff;
  575. /* Test for 64K boundary crossing and return count large */
  576. /* enough not to exceed the threshold. */
  577. count = (((ltemp + SEC_SIZE * count) & 0xffff0000l) != 0l)
  578. ? (0xffffl - ltemp) / SEC_SIZE
  579. : count;
  580. #endif
  582. *trackp = strt_sect / (miarray[unit].mi_heads * miarray[unit].mi_sectors);
  583. *sectorp = strt_sect % miarray[unit].mi_sectors + 1;
  584. *headp = (strt_sect % (miarray[unit].mi_sectors * miarray[unit].mi_heads))
  585. / miarray[unit].mi_sectors;
  586. if(((ls = *headp * miarray[unit].mi_sectors + *sectorp - 1) + count) >
  587. (ps = miarray[unit].mi_heads * miarray[unit].mi_sectors))
  588. count = ps - ls;
  589. return count;
  590. }