Subversion Repositories pentevo

Rev

Rev 1159 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5.  
  6. #include "util.h"
  7.  
  8. //#define DUMP_HDD_IO 1
  9.  
  10. const unsigned MAX_DEVICES = MAX_PHYS_HD_DRIVES+2*MAX_PHYS_CD_DRIVES;
  11.  
  12. PHYS_DEVICE phys[MAX_DEVICES];
  13. unsigned n_phys = 0;
  14.  
  15. /*
  16. // this function is untested
  17. void ATA_DEVICE::exec_mode_select()
  18. {
  19.    intrq = 1;
  20.    command_ok();
  21.  
  22.    struct {
  23.       SCSI_PASS_THROUGH_DIRECT p;
  24.       unsigned char sense[0x40];
  25.    } srb = { 0 }, dst;
  26.  
  27.    srb.p.Length = sizeof(SCSI_PASS_THROUGH_DIRECT);
  28.    *(CDB*)&srb.p.Cdb = cdb;
  29.    srb.p.CdbLength = sizeof(CDB);
  30.    srb.p.DataIn = SCSI_IOCTL_DATA_OUT;
  31.    srb.p.TimeOutValue = 10;
  32.    srb.p.DataBuffer = transbf;
  33.    srb.p.DataTransferLength = transcount;
  34.    srb.p.SenseInfoLength = sizeof(srb.sense);
  35.    srb.p.SenseInfoOffset = sizeof(SCSI_PASS_THROUGH_DIRECT);
  36.  
  37.    DWORD outsize;
  38.    int r = DeviceIoControl(hDevice, IOCTL_SCSI_PASS_THROUGH_DIRECT,
  39.                            &srb.p, sizeof(srb.p),
  40.                            &dst, sizeof(dst),
  41.                            &outsize, 0);
  42.  
  43.    if (!r) return;
  44.    if (senselen = dst.p.SenseInfoLength) memcpy(sense, dst.sense, senselen);
  45.    return;
  46. }
  47. */
  48.  
  49. void init_hdd_cd()
  50. {
  51.    memset(&phys, 0, sizeof phys);
  52.    if (conf.ide_skip_real)
  53.        return;
  54.  
  55.    n_phys = 0;
  56.    n_phys = ATA_PASSER::identify(phys + n_phys, MAX_DEVICES - n_phys);
  57.    n_phys += ATAPI_PASSER::identify(phys + n_phys, MAX_DEVICES - n_phys);
  58.  
  59.    if (!n_phys)
  60.        errmsg("HDD/CD emulator can't access physical drives");
  61. }
  62.  
  63. static void delstr_spaces(char *dst, char *src)
  64. {
  65.    for (; *src; src++)
  66.       if (*src != ' ') *dst++ = *src;
  67.    *dst = 0;
  68. }
  69.  
  70. unsigned find_hdd_device(char *name)
  71. {
  72.    char s2[512];
  73.    delstr_spaces(s2, name);
  74. //   if(temp.win9x)
  75.    for (unsigned drive = 0; drive < n_phys; drive++)
  76.    {
  77.       char s1[512];
  78.       delstr_spaces(s1, phys[drive].viewname);
  79.       if (!stricmp(s1,s2))
  80.           return drive;
  81.    }
  82.    return -1U;
  83. }
  84.  
  85. void ATA_DEVICE::configure(IDE_CONFIG *cfg)
  86. {
  87.    atapi_p.close(); ata_p.close();
  88.  
  89.    c = cfg->c; h = cfg->h; s = cfg->s; lba = cfg->lba; readonly = cfg->readonly;
  90.  
  91.    memset(&reg, 0, sizeof(reg)); // ╬ўш∙рхь ЁхушёЄЁ√
  92.    command_ok(); // ╤сЁрё√трхь ёюёЄю эшх ш яючшЎш■ яхЁхфрўш фрээ√ї
  93.  
  94.    phys_dev = -1U;
  95.    if (!*cfg->image)
  96.        return;
  97.  
  98.    PHYS_DEVICE filedev, *dev;
  99.    phys_dev = find_hdd_device(cfg->image);
  100.    if (phys_dev == -1U)
  101.    {
  102.       if (cfg->image[0] == '<')
  103.       {
  104.           errmsg("no physical device %s", cfg->image);
  105.           *cfg->image = 0;
  106.           return;
  107.       }
  108.       strcpy(filedev.filename, cfg->image);
  109.       filedev.type = cfg->cd ? ATA_FILECD : ATA_FILEHDD;
  110.       dev = &filedev;
  111.    }
  112.    else
  113.    {
  114.       dev = &phys[phys_dev];
  115.       if (dev->type == ATA_NTHDD)
  116.       {
  117.          // read geometry from id sector
  118.          c = *(unsigned short*)(phys[phys_dev].idsector+2);
  119.          h = *(unsigned short*)(phys[phys_dev].idsector+6);
  120.          s = *(unsigned short*)(phys[phys_dev].idsector+12);
  121.          lba = *(unsigned*)(phys[phys_dev].idsector+0x78); // lba28
  122.          if(*((u16*)(phys[phys_dev].idsector+83*2)) & (1<<10))
  123.          {
  124.              lba = *(u64*)(phys[phys_dev].idsector+100*2); // lba48
  125.          }
  126.          if (!lba)
  127.              lba = c*h*s;
  128.       }
  129.    }
  130.    DWORD errcode = ERROR_DEVICE_NOT_AVAILABLE;
  131.    if (dev->type == ATA_NTHDD || dev->type == ATA_FILEHDD)
  132.    {
  133.        dev->usage = ATA_OP_USE;
  134.        errcode = ata_p.open(dev);
  135.        atapi = 0;
  136.    }
  137.  
  138.    if (dev->type == ATA_SPTI_CD || dev->type == ATA_ASPI_CD || dev->type == ATA_FILECD)
  139.    {
  140.        dev->usage = ATA_OP_USE;
  141.        errcode = atapi_p.open(dev);
  142.        atapi = 1;
  143.    }
  144.  
  145.    if (errcode == NO_ERROR)
  146.        return;
  147.    errmsg("failed to open %s", cfg->image);
  148.    err_win32(errcode);
  149.    *cfg->image = 0;
  150. }
  151.  
  152. void ATA_PORT::reset()
  153. {
  154.    dev[0].reset(ATA_DEVICE::RESET_HARD);
  155.    dev[1].reset(ATA_DEVICE::RESET_HARD);
  156. }
  157.  
  158. unsigned char ATA_PORT::read(unsigned n_reg)
  159. {
  160.    u8 val1 = dev[0].read(n_reg);
  161.    u8 val2 = dev[1].read(n_reg);
  162.  
  163.    unsigned devs = 0;
  164.    devs |= (dev[0].loaded() ? 1 : 0);
  165.    devs |= (dev[1].loaded() ? 2 : 0);
  166.  
  167.    u8 val = 0xFF;
  168.    switch(devs)
  169.    {
  170.    case 1: val = val1; break;
  171.    case 2: val = val2; break;
  172.    case 3: val = dev[0].selected() ? val1 : val2; break;
  173.    }
  174.  
  175. #ifdef DUMP_HDD_IO
  176.    printf("R%X:%02X ", n_reg, val);
  177. #endif
  178.    return val;
  179. }
  180.  
  181. unsigned ATA_PORT::read_data()
  182. {
  183. #ifdef DUMP_HDD_IO
  184.    unsigned val = dev[0].read_data() & dev[1].read_data();
  185.    printf("r%04X ", val & 0xFFFF);
  186.    return val;
  187. #endif
  188.    return dev[0].read_data() & dev[1].read_data();
  189. }
  190.  
  191. void ATA_PORT::write(unsigned n_reg, unsigned char data)
  192. {
  193. #ifdef DUMP_HDD_IO
  194.    printf("R%X=%02X ", n_reg, data);
  195. #endif
  196.    dev[0].write(n_reg, data);
  197.    dev[1].write(n_reg, data);
  198. }
  199.  
  200. void ATA_PORT::write_data(unsigned data)
  201. {
  202. #ifdef DUMP_HDD_IO
  203.    printf("w%04X ", data & 0xFFFF);
  204. #endif
  205.    dev[0].write_data(data);
  206.    dev[1].write_data(data);
  207. }
  208.  
  209. unsigned char ATA_PORT::read_intrq()
  210. {
  211. #ifdef DUMP_HDD_IO
  212. unsigned char i = dev[0].read_intrq() & dev[1].read_intrq(); printf("i%d ", !!i); return i;
  213. #endif
  214.    return dev[0].read_intrq() & dev[1].read_intrq();
  215. }
  216.  
  217. void ATA_DEVICE::reset_signature(RESET_TYPE mode)
  218. {
  219.    reg.count = reg.sec = 1;
  220.    reg.err = 1;
  221.    reg.cyl = atapi ? 0xEB14 : 0;
  222.    reg.devhead |= 0x50;
  223.    reg.devhead &= (atapi && mode == RESET_SOFT) ? 0x10 : 0;
  224.    reg.status = (mode == RESET_SOFT || !atapi) ? STATUS_DRDY | STATUS_DSC : 0;
  225. }
  226.  
  227. void ATA_DEVICE::reset(RESET_TYPE mode)
  228. {
  229.    reg.control = 0; // clear SRST
  230.    intrq = 0;
  231.    regs_sel = 0;
  232.  
  233.    command_ok();
  234.    reset_signature(mode);
  235. }
  236.  
  237. void ATA_DEVICE::command_ok()
  238. {
  239.    state = S_IDLE;
  240.    transptr = -1U;
  241.    reg.err = 0;
  242.    reg.status = STATUS_DRDY | STATUS_DSC;
  243. }
  244.  
  245. unsigned char ATA_DEVICE::read_intrq()
  246. {
  247.    if (!loaded() || ((reg.devhead ^ device_id) & 0x10) || (reg.control & CONTROL_nIEN)) return 0xFF;
  248.    return intrq? 0xFF : 0x00;
  249. }
  250.  
  251. unsigned char ATA_DEVICE::read(unsigned n_reg)
  252. {
  253. //printf("%s: n_reg=%08x\n", __PRETTY_FUNCTION__, n_reg);
  254.    if (!loaded())
  255.        return 0xFF;
  256.  
  257. /*
  258.    if ((reg.devhead ^ device_id) & 0x10)
  259.    {
  260.        return 0xFF;
  261.    }
  262. */
  263.  
  264.    if (n_reg == 7)
  265.        intrq = 0;
  266.    if (n_reg == 8)
  267.        n_reg = 7; // read alt.status -> read status
  268.  
  269.    if ((n_reg == 7) && ((reg.devhead ^ device_id) & 0x10))
  270.    {
  271.        return 0;
  272.    }
  273.  
  274.    if (n_reg == 7 || (reg.status & STATUS_BSY))
  275.    {
  276. //         printf("state=%d\n",state); //Alone Coder
  277.            return reg.status;
  278.    } // BSY=1 or read status
  279.    // BSY = 0
  280.    //// if (reg.status & STATUS_DRQ) return 0xFF;    // DRQ.  ATA-5: registers should not be queried while DRQ=1, but programs do this!
  281.  
  282.    update_regs();
  283.    // DRQ = 0
  284.    unsigned sel = regs_sel;
  285.    if(lba > 0xFFFFFFFULL)
  286.    { // lba48
  287.        sel ^= (reg.control & CONTROL_HOB) ? 1 : 0;
  288.    }
  289.  
  290.    return *regs_r[sel][n_reg];
  291. }
  292.  
  293. unsigned ATA_DEVICE::read_data()
  294. {
  295.    if (!loaded())
  296.        return 0xFFFFFFFF;
  297.    if ((reg.devhead ^ device_id) & 0x10)
  298.        return 0xFFFFFFFF;
  299.    if (/* (reg.status & (STATUS_DRQ | STATUS_BSY)) != STATUS_DRQ ||*/ transptr >= transcount)
  300.        return 0xFFFFFFFF;
  301.  
  302.    // DRQ=1, BSY=0, data present
  303.    unsigned result = *(unsigned*)(transbf + transptr*2);
  304.    transptr++;
  305. //   printf("%s data=0x%04X\n", __FUNCTION__, result & 0xFFFF);
  306.  
  307.    if (transptr < transcount)
  308.        return result;
  309.    // look to state, prepare next block
  310.    if (state == S_READ_ID || state == S_READ_ATAPI)
  311.        command_ok();
  312.    if (state == S_READ_SECTORS)
  313.    {
  314. //       __debugbreak();
  315. //       printf("dev=%d, cnt=%d\n", device_id, reg.count);
  316.        if(!--reg.count)
  317.            command_ok();
  318.        else
  319.        {
  320.            next_sector();
  321.            read_sectors();
  322.        }
  323.    }
  324.  
  325.    return result;
  326. }
  327.  
  328. char ATA_DEVICE::exec_ata_cmd(unsigned char cmd)
  329. {
  330. //   printf(__FUNCTION__" cmd=%02X\n", cmd);
  331.    // EXECUTE DEVICE DIAGNOSTIC for both ATA and ATAPI
  332.    if (cmd == 0x90)
  333.    {
  334.        reset_signature(RESET_SOFT);
  335.        return 1;
  336.    }
  337.  
  338.    if (atapi)
  339.        return 0;
  340.  
  341.    // INITIALIZE DEVICE PARAMETERS
  342.    if (cmd == 0x91)
  343.    {
  344.      // pos = (reg.cyl * h + (reg.devhead & 0x0F)) * s + reg.sec - 1;
  345.      h = (reg.devhead & 0xF) + 1;
  346.      s = reg.count;
  347.      if(s == 0)
  348.      {
  349.           reg.status = STATUS_DRDY | STATUS_DF | STATUS_DSC | STATUS_ERR;
  350.           return 1;
  351.      }
  352.  
  353.      c = unsigned(lba / s / h);
  354.  
  355.      reg.status = STATUS_DRDY | STATUS_DSC;
  356.      return 1;
  357.    }
  358.  
  359.    if ((cmd & 0xFE) == 0x20) // ATA-3 (mandatory), read sectors (20-w-retr/21-wo-retr)
  360.    { // cmd #21 obsolette, rqd for is-dos
  361. //       printf(__FUNCTION__" sec_cnt=%d\n", reg.count);
  362. //       __debugbreak();
  363.        read_sectors();
  364.        return 1;
  365.    }
  366.  
  367.    if ((cmd == 0x24) && (lba > 0xFFFFFFFULL)) // ATA-6 read sectors ext (lba48)
  368.    {
  369.        read_sectors();
  370.        return 1;
  371.    }
  372.  
  373.  
  374.    if((cmd & 0xFE) == 0x40) // ATA-3 (mandatory),  verify sectors
  375.    { //rqd for is-dos
  376.        verify_sectors();
  377.        return 1;
  378.    }
  379.  
  380.    if ((cmd == 0x42) && (lba > 0xFFFFFFFULL)) // ATA-6 verify sectors ext (lba48)
  381.    {
  382.        verify_sectors();
  383.        return 1;
  384.    }
  385.  
  386.    if ((cmd & 0xFE) == 0x30 && !readonly) // ATA-3 (mandatory), write sectors (30-w-retr,31-wo-retr)
  387.    {
  388.       if (seek())
  389.       {
  390.           state = S_WRITE_SECTORS;
  391.           reg.status = STATUS_DRQ | STATUS_DSC;
  392.           transptr = 0;
  393.           transcount = 0x100;
  394.       }
  395.       return 1;
  396.    }
  397.  
  398.    if ((cmd == 0x34) && (lba > 0xFFFFFFFULL) && !readonly) // ATA-6 write sectors ext (lba48)
  399.    {
  400.       if (seek())
  401.       {
  402.           state = S_WRITE_SECTORS;
  403.           reg.status = STATUS_DRQ | STATUS_DSC;
  404.           transptr = 0;
  405.           transcount = 0x100;
  406.       }
  407.       return 1;
  408.    }
  409.  
  410.    if(cmd == 0x50) // format track (фрээр  ЁхрышчрЎш  - эшўхую эх фхырхЄ)
  411.    {
  412.       reg.sec = 1;
  413.       if (seek())
  414.       {
  415.           state = S_FORMAT_TRACK;
  416.           reg.status = STATUS_DRQ | STATUS_DSC;
  417.           transptr = 0;
  418.           transcount = 0x100;
  419.       }
  420.       return 1;
  421.    }
  422.  
  423.    if (cmd == 0xEC)
  424.    {
  425.        prepare_id();
  426.        return 1;
  427.    }
  428.  
  429.    if (cmd == 0xE7)
  430.    { // FLUSH CACHE
  431.       if (ata_p.flush())
  432.       {
  433.           command_ok();
  434.           intrq = 1;
  435.       }
  436.       else
  437.           reg.status = STATUS_DRDY | STATUS_DF | STATUS_DSC | STATUS_ERR; // 0x71
  438.       return 1;
  439.    }
  440.  
  441.    if (cmd == 0x10)
  442.    {
  443.       recalibrate();
  444.       command_ok();
  445.       intrq = 1;
  446.       return 1;
  447.    }
  448.  
  449.    if (cmd == 0x70)
  450.    { // seek
  451.       if (!seek())
  452.           return 1;
  453.       command_ok();
  454.       intrq = 1;
  455.       return 1;
  456.    }
  457.  
  458.    printf("*** unknown ata cmd %02X ***\n", cmd);
  459.  
  460.    return 0;
  461. }
  462.  
  463. char ATA_DEVICE::exec_atapi_cmd(unsigned char cmd)
  464. {
  465.    if (!atapi)
  466.        return 0;
  467. //printf("atapi cmd: %02X\n", cmd);
  468.    // soft reset
  469.    if (cmd == 0x08)
  470.    {
  471.        reset(RESET_SOFT);
  472.        return 1;
  473.    }
  474.    if (cmd == 0xA1) // IDENTIFY PACKET DEVICE
  475.    {
  476.        prepare_id();
  477.        return 1;
  478.    }
  479.  
  480.    if (cmd == 0xA0)
  481.    { // packet
  482.       state = S_RECV_PACKET;
  483.       reg.status = STATUS_DRQ;
  484.       reg.intreason = INT_COD;
  485.       transptr = 0;
  486.       transcount = 6;
  487.       return 1;
  488.    }
  489.  
  490.    if (cmd == 0xEC)
  491.    {
  492.        reg.count = 1;
  493.        reg.sec = 1;
  494.        reg.cyl = 0xEB14;
  495.  
  496.        reg.status = STATUS_DSC | STATUS_DRDY | STATUS_ERR;
  497.        reg.err = ERR_ABRT;
  498.        state = S_IDLE;
  499.        intrq = 1;
  500.        return 1;
  501.    }
  502.  
  503.    printf("*** unknown atapi cmd %02X ***\n", cmd);
  504.    // "command aborted" with ATAPI signature
  505.    reg.count = 1;
  506.    reg.sec = 1;
  507.    reg.cyl = 0xEB14;
  508.    return 0;
  509. }
  510.  
  511. void ATA_DEVICE::write(unsigned n_reg, unsigned char data)
  512. {
  513. //   printf("dev=%d, reg=%d, data=%02X\n", device_id, n_reg, data);
  514.    if (!loaded())
  515.        return;
  516.  
  517.    reg.control &= ~CONTROL_HOB;
  518.  
  519.    if (n_reg == 1)
  520.    {
  521.        reg.feat = data;
  522.        return;
  523.    }
  524.  
  525.    if (n_reg != 7) // ═х ЁхушёЄЁ ъюьрэф
  526.    {
  527.       *regs_w[regs_sel][n_reg] = data;
  528.       regs_sel ^= (lba > 0xFFFFFFFULL) ? 1 : 0;
  529.  
  530.       update_cur();
  531.  
  532.       if (reg.control & CONTROL_SRST)
  533.       {
  534. //          printf("dev=%d, reset\n", device_id);
  535.           reset(RESET_SRST);
  536.       }
  537.       return;
  538.    }
  539.  
  540.    // execute command!
  541.    if (((reg.devhead ^ device_id) & 0x10) && data != 0x90)
  542.        return;
  543.    if (!(reg.status & STATUS_DRDY) && !atapi)
  544.    {
  545.        printf("warning: hdd not ready cmd = %02X (ignored)\n", data);
  546.        return;
  547.    }
  548.  
  549.    reg.err = 0; intrq = 0;
  550.  
  551. //{printf(" [");for (int q=1;q<9;q++) printf("-%02X",regs[q]);printf("]\n");}
  552.    if (exec_atapi_cmd(data))
  553.        return;
  554.    if (exec_ata_cmd(data))
  555.        return;
  556.    reg.status = STATUS_DSC | STATUS_DRDY | STATUS_ERR;
  557.    reg.err = ERR_ABRT;
  558.    state = S_IDLE; intrq = 1;
  559. }
  560.  
  561. void ATA_DEVICE::write_data(unsigned data)
  562. {
  563.    if (!loaded()) return;
  564.    if ((reg.devhead ^ device_id) & 0x10)
  565.        return;
  566.    if (/* (reg.status & (STATUS_DRQ | STATUS_BSY)) != STATUS_DRQ ||*/ transptr >= transcount)
  567.        return;
  568.    *(unsigned short*)(transbf + transptr*2) = (unsigned short)data; transptr++;
  569.    if (transptr < transcount)
  570.        return;
  571.    // look to state, prepare next block
  572.    if (state == S_WRITE_SECTORS)
  573.    {
  574.        write_sectors();
  575.        return;
  576.    }
  577.  
  578.    if (state == S_FORMAT_TRACK)
  579.    {
  580.        format_track();
  581.        return;
  582.    }
  583.  
  584.    if (state == S_RECV_PACKET)
  585.    {
  586.        handle_atapi_packet();
  587.        return;
  588.    }
  589. /*   if (state == S_MODE_SELECT) { exec_mode_select(); return; } */
  590. }
  591.  
  592. char ATA_DEVICE::seek()
  593. {
  594.    u64 pos;
  595.    if (reg.devhead & 0x40)
  596.    {
  597.       pos = lba_cur;
  598.       if (lba_cur >= lba)
  599.       {
  600. //          printf("seek error: lba %I64u:%I64u\n", lba, pos);
  601.  
  602.           seek_err:
  603.           reg.status = STATUS_DRDY | STATUS_DF | STATUS_ERR;
  604.           reg.err = ERR_IDNF | ERR_ABRT;
  605.           intrq = 1;
  606.           return 0;
  607.       }
  608. //      printf("lba %I64u:%I64u\n", lba, pos);
  609.    }
  610.    else
  611.    {
  612.       if (c_cur >= c || h_cur >= h || s_cur > s || s_cur == 0)
  613.       {
  614. //          printf("seek error: chs %4d/%02d/%02d\n", c_cur,  h_cur, s_cur);
  615.           goto seek_err;
  616.       }
  617.       pos = (c_cur * h + h_cur) * s + s_cur - 1;
  618. //      printf("chs %4d/%02d/%02d: %I64u\n", c_cur,  h_cur, s_cur, pos);
  619.    }
  620. //printf("[seek %I64u]", pos << 9);
  621.    if (!ata_p.seek(pos))
  622.    {
  623.       reg.status = STATUS_DRDY | STATUS_DF | STATUS_ERR;
  624.       reg.err = ERR_IDNF | ERR_ABRT;
  625.       intrq = 1;
  626.       return 0;
  627.    }
  628.    return 1;
  629. }
  630.  
  631. void ATA_DEVICE::format_track()
  632. {
  633.    intrq = 1;
  634.    if(!seek())
  635.        return;
  636.  
  637.    command_ok();
  638.    return;
  639. }
  640.  
  641. void ATA_DEVICE::write_sectors()
  642. {
  643.    intrq = 1;
  644. //printf(" [write] ");
  645.    if(!seek())
  646.        return;
  647.  
  648.    if (!ata_p.write_sector(transbf))
  649.    {
  650.       reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  651.       reg.err = ERR_UNC;
  652.       state = S_IDLE;
  653.       return;
  654.    }
  655.  
  656.    if (!--reg.count)
  657.    {
  658.        command_ok();
  659.        return;
  660.    }
  661.    next_sector();
  662.  
  663.    transptr = 0; transcount = 0x100;
  664.    state = S_WRITE_SECTORS;
  665.    reg.err = 0;
  666.    reg.status = STATUS_DRQ | STATUS_DSC;
  667. }
  668.  
  669. void ATA_DEVICE::read_sectors()
  670. {
  671. //   __debugbreak();
  672.    intrq = 1;
  673.    if (!seek())
  674.       return;
  675.  
  676.    if (!ata_p.read_sector(transbf))
  677.    {
  678.       reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  679.       reg.err = ERR_UNC | ERR_IDNF;
  680.       state = S_IDLE;
  681.       return;
  682.    }
  683.    transptr = 0;
  684.    transcount = 0x100;
  685.    state = S_READ_SECTORS;
  686.    reg.err = 0;
  687.    reg.status = STATUS_DRDY | STATUS_DRQ | STATUS_DSC;
  688.  
  689. /*
  690.    if(reg.devhead & 0x40)
  691.        printf("dev=%d lba=%d\n", device_id, *(unsigned*)(regs+3) & 0x0FFFFFFF);
  692.    else
  693.        printf("dev=%d c/h/s=%d/%d/%d\n", device_id, reg.cyl, (reg.devhead & 0xF), reg.sec);
  694. */
  695. }
  696.  
  697. void ATA_DEVICE::verify_sectors()
  698. {
  699.    intrq = 1;
  700. //   __debugbreak();
  701.  
  702.    do
  703.    {
  704.        --n_cur;
  705. /*
  706.        if(reg.devhead & 0x40)
  707.            printf("lba=%d\n", *(unsigned*)(regs+3) & 0x0FFFFFFF);
  708.        else
  709.            printf("c/h/s=%d/%d/%d\n", reg.cyl, (reg.devhead & 0xF), reg.sec);
  710. */
  711.        if (!seek())
  712.            return;
  713. /*
  714.        u8 Buf[512];
  715.        if (!ata_p.read_sector(Buf))
  716.        {
  717.           reg.status = STATUS_DRDY | STATUS_DF | STATUS_CORR | STATUS_DSC | STATUS_ERR;
  718.           reg.err = ERR_UNC | ERR_IDNF | ERR_ABRT | ERR_AMNF;
  719.           state = S_IDLE;
  720.           return;
  721.        }
  722. */
  723.        if(n_cur)
  724.            next_sector();
  725.    }while(n_cur);
  726.    command_ok();
  727. }
  728.  
  729. void ATA_DEVICE::next_sector()
  730. {
  731.    if (reg.devhead & 0x40)
  732.    { // LBA
  733.       lba_cur++;
  734.       return;
  735.    }
  736.    // need to recalc CHS for every sector, coz ATA registers
  737.    // should contain current position on failure
  738.    if (s_cur < s)
  739.    {
  740.        s_cur++;
  741.        return;
  742.    }
  743.    s_cur = 1;
  744.  
  745.    if (++h_cur < h)
  746.    {
  747.        return;
  748.    }
  749.    h_cur = 0;
  750.    c_cur++;
  751. }
  752.  
  753. void ATA_DEVICE::recalibrate()
  754. {
  755.    lba_cur = 0;
  756.    c_cur = 0;
  757.    h_cur = 0;
  758.    s_cur = 1;
  759.  
  760.    reg.cyl = 0;
  761.    reg.devhead &= 0xF0;
  762.  
  763.    if (reg.devhead & 0x40) // LBA
  764.    {
  765.       reg.sec = 0;
  766.       return;
  767.    }
  768.  
  769.    reg.sec = 1;
  770. }
  771.  
  772. #define TOC_DATA_TRACK          0x04
  773.  
  774. // [vv] ╨рсюЄр ё Їрщыюь - юсЁрчюь фшёър эряЁ ьє■
  775. void ATA_DEVICE::handle_atapi_packet_emulate()
  776. {
  777. //    printf("%s\n", __FUNCTION__);
  778.     memcpy(&atapi_p.cdb, transbf, 12);
  779.  
  780.     switch(atapi_p.cdb.CDB12.OperationCode)
  781.     {
  782.     case SCSIOP_TEST_UNIT_READY:; // 6
  783.           command_ok();
  784.           return;
  785.  
  786.     case SCSIOP_READ:; // 10
  787.     {
  788.       unsigned cnt = (u32(atapi_p.cdb.CDB10.TransferBlocksMsb) << 8) | atapi_p.cdb.CDB10.TransferBlocksLsb;
  789.       unsigned pos = (u32(atapi_p.cdb.CDB10.LogicalBlockByte0) << 24) |
  790.                      (u32(atapi_p.cdb.CDB10.LogicalBlockByte1) << 16) |
  791.                      (u32(atapi_p.cdb.CDB10.LogicalBlockByte2) << 8) |
  792.                      atapi_p.cdb.CDB10.LogicalBlockByte3;
  793.  
  794.       if(cnt * 2048 > sizeof(transbf))
  795.       {
  796.           reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  797.           reg.err = ERR_UNC | ERR_IDNF;
  798.           state = S_IDLE;
  799.           return;
  800.       }
  801.  
  802.       for(unsigned i = 0; i < cnt; i++, pos++)
  803.       {
  804.           if (!atapi_p.seek(pos))
  805.           {
  806.              reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  807.              reg.err = ERR_UNC | ERR_IDNF;
  808.              state = S_IDLE;
  809.              return;
  810.           }
  811.  
  812.           if (!atapi_p.read_sector(transbf + i * 2048))
  813.           {
  814.              reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  815.              reg.err = ERR_UNC | ERR_IDNF;
  816.              state = S_IDLE;
  817.              return;
  818.           }
  819.       }
  820.       intrq = 1;
  821.       reg.atapi_count = u16(cnt * 2048);
  822.       reg.intreason = INT_IO;
  823.       reg.status = STATUS_DRQ;
  824.       transcount = (cnt * 2048)/2;
  825.       transptr = 0;
  826.       state = S_READ_ATAPI;
  827.       return;
  828.     }
  829.  
  830.     case SCSIOP_READ_TOC:; // 10
  831.     {
  832.       static const u8 TOC_DATA[] =
  833.       {
  834.         0, 4+8*2 - 2, 1, 0xAA,
  835.         0, TOC_DATA_TRACK, 1, 0, 0, 0, 0, 0,
  836.         0, TOC_DATA_TRACK, 0xAA, 0, 0, 0, 0, 0,
  837.       };
  838.       unsigned len = sizeof(TOC_DATA);
  839.       memcpy(transbf, TOC_DATA, len);
  840.       reg.atapi_count = u16(len);
  841.       reg.intreason = INT_IO;
  842.       reg.status = STATUS_DRQ;
  843.       transcount = (len + 1)/2;
  844.       transptr = 0;
  845.       state = S_READ_ATAPI;
  846.       return;
  847.     }
  848.     case SCSIOP_START_STOP_UNIT:; // 10
  849.           command_ok();
  850.           return;
  851.  
  852.     case SCSIOP_SET_CD_SPEED:; // 12
  853.           command_ok();
  854.           return;
  855.  
  856.     /////////////////////////////////////////////////////////////////////////
  857.     case SCSIOP_MODE_SENSE_10:
  858.     {
  859.         unsigned len;
  860.  
  861.         len = atapi_p.cdb.MODE_SENSE10.AllocationLength[0]*256 + atapi_p.cdb.MODE_SENSE10.AllocationLength[1];
  862.         memset(transbf,0,len);
  863.  
  864.         // following piece of code taken from MAME
  865.         const uint8_t page = atapi_p.cdb.MODE_SENSE10.PageCode;
  866.         int ptr = 8;
  867. //printf("5a: len=%04x, page=%02x\n",len,page);
  868.         if ((page == 0xe) || (page == 0x3f))
  869.         {
  870.             // CD Audio control page
  871.             transbf[ptr++] = 0x8e; // page E, parameter is savable
  872.             transbf[ptr++] = 0x0e; // page length
  873.             //transbf[ptr++] = (1 << 2) | (m_sotc << 1); // IMMED = 1
  874.             transbf[ptr++] = (1 << 2);
  875.             // reserved
  876.             transbf[ptr++] = 0;
  877.             transbf[ptr++] = 0;
  878.             transbf[ptr++] = 0;
  879.             transbf[ptr++] = 0;
  880.             transbf[ptr++] = 0;
  881.             // connect each audio channel to 1 output port and indicate max volume
  882.             transbf[ptr++] = 1;
  883.             transbf[ptr++] = 0xff;
  884.             transbf[ptr++] = 2;
  885.             transbf[ptr++] = 0xff;
  886.             transbf[ptr++] = 4;
  887.             transbf[ptr++] = 0xff;
  888.             transbf[ptr++] = 8;
  889.             transbf[ptr++] = 0xff;
  890.         }
  891.         if ((page == 0x0d) || (page == 0x3f))
  892.         {
  893.             // CD page
  894.             transbf[ptr++] = 0x0d;
  895.             transbf[ptr++] = 6;    // page length
  896.             transbf[ptr++] = 0;
  897.             transbf[ptr++] = 0;
  898.             transbf[ptr++] = 0;
  899.             transbf[ptr++] = 60;
  900.             transbf[ptr++] = 0;
  901.             transbf[ptr++] = 75;
  902.         }
  903.         if ((page == 0x2a) || (page == 0x3f))
  904.         {
  905.             // Page capabilities
  906.             transbf[ptr++] = 0x2a;
  907.             transbf[ptr++] = 0x14; // page length
  908.             transbf[ptr++] = 0x00;
  909.             transbf[ptr++] = 0x00; // CD-R only
  910.             transbf[ptr++] = (1 << 4) | // Mode 2 Form 1
  911.                              (1 << 1) | // XA Cmds Supported
  912.                              (1 << 0); // AudioPlay
  913.             transbf[ptr++] = 0;
  914.             transbf[ptr++] = 0;
  915.             transbf[ptr++] = 0;
  916.             transbf[ptr++] = 0x02;
  917.             transbf[ptr++] = 0xc0; // 4x speed
  918.             transbf[ptr++] = 0x01;
  919.             transbf[ptr++] = 0x00; // 256 volume levels supported
  920.             transbf[ptr++] = 0x00;
  921.             transbf[ptr++] = 0x00; // buffer
  922.             transbf[ptr++] = 0x02;
  923.             transbf[ptr++] = 0xc0; // 4x read speed
  924.             transbf[ptr++] = 0;
  925.             transbf[ptr++] = 0;
  926.             transbf[ptr++] = 0;
  927.             transbf[ptr++] = 0;
  928.             transbf[ptr++] = 0;
  929.             transbf[ptr++] = 0;
  930.         }
  931.  
  932.         //
  933.         reg.atapi_count = u16(len);
  934.         reg.intreason = INT_IO;
  935.         reg.status = STATUS_DRQ;
  936.         transcount = (len+1)/2;
  937.         transptr = 0;
  938.         state = S_READ_ATAPI;
  939.         return;
  940.     }
  941.  
  942.     /////////////////////////////////////////////////////////////////////////
  943.     case SCSIOP_READ_CAPACITY_10:
  944.     {
  945.         unsigned len;
  946.  
  947.         len = 8;
  948.  
  949.         transbf[0] = (lba>>24) & 0xFF;
  950.         transbf[1] = (lba>>16) & 0xFF;
  951.         transbf[2] = (lba>> 8) & 0xFF;
  952.         transbf[3] =  lba      & 0xFF;
  953.  
  954.         transbf[4] = 0;
  955.         transbf[5] = 0;
  956.         transbf[6] = 2048/256;
  957.         transbf[7] = 0;
  958.  
  959.  
  960. //printf("25: lba=%08llX\n",lba);
  961.         //
  962.         reg.atapi_count = u16(len);
  963.         reg.intreason = INT_IO;
  964.         reg.status = STATUS_DRQ;
  965.         transcount = (len+1)/2;
  966.         transptr = 0;
  967.         state = S_READ_ATAPI;
  968.         return;
  969.     }
  970.  
  971.     /////////////////////////////////////////////////////////////////////////
  972.     case SCSIOP_READ_CD:
  973.     {
  974.         unsigned pos;
  975.         unsigned cnt;
  976.  
  977.         pos = atapi_p.cdb.READ_CD.LogicalBlock[0] * 0x01000000 +
  978.               atapi_p.cdb.READ_CD.LogicalBlock[1] * 0x00010000 +
  979.               atapi_p.cdb.READ_CD.LogicalBlock[2] * 0x00000100 +
  980.               atapi_p.cdb.READ_CD.LogicalBlock[3]              ;
  981.  
  982.         cnt = atapi_p.cdb.READ_CD.TransferLenBlk[0] * 0x010000 +
  983.               atapi_p.cdb.READ_CD.TransferLenBlk[1] * 0x000100 +
  984.               atapi_p.cdb.READ_CD.TransferLenBlk[2]            ;
  985. //printf("be: lba=%08X, cnt=%06X, byte9=%02X, subch=%01X\n", pos, cnt, *(9+((uint8_t *)&atapi_p.cdb)), atapi_p.cdb.READ_CD.SubChSelBits);
  986.         if( atapi_p.cdb.READ_CD.Sync     ||
  987.             atapi_p.cdb.READ_CD.HdrCodes ||
  988.            !atapi_p.cdb.READ_CD.UserData ||
  989.             atapi_p.cdb.READ_CD.EdcEcc   ||
  990.             atapi_p.cdb.READ_CD.ErrField )
  991.         {
  992.             reg.err = 0;
  993.             state = S_IDLE;
  994.             reg.status = STATUS_DSC | STATUS_ERR | STATUS_DRDY;
  995. printf("scsi cmd be: BAD FLAGS!\n");
  996.             return;
  997.         }
  998.  
  999.         // do below as in READ
  1000.         if( cnt*2048 > sizeof(transbf) )
  1001.         {
  1002.             reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  1003.             reg.err = ERR_UNC | ERR_IDNF;
  1004.             state = S_IDLE;
  1005.             return;
  1006.         }
  1007.  
  1008.         for(unsigned i = 0; i < cnt; i++, pos++)
  1009.         {
  1010.             if (!atapi_p.seek(pos))
  1011.             {
  1012.                reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  1013.                reg.err = ERR_UNC | ERR_IDNF;
  1014.                state = S_IDLE;
  1015.                return;
  1016.             }
  1017.        
  1018.             if (!atapi_p.read_sector(transbf + i * 2048))
  1019.             {
  1020.                reg.status = STATUS_DRDY | STATUS_DSC | STATUS_ERR;
  1021.                reg.err = ERR_UNC | ERR_IDNF;
  1022.                state = S_IDLE;
  1023.                return;
  1024.             }
  1025.         }
  1026.         intrq = 1;
  1027.         reg.atapi_count = u16(cnt * 2048);
  1028.         reg.intreason = INT_IO;
  1029.         reg.status = STATUS_DRQ;
  1030.         transcount = (cnt * 2048)/2;
  1031.         transptr = 0;
  1032.         state = S_READ_ATAPI;
  1033.         return;
  1034.     }
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040.  
  1041.     }
  1042.  
  1043.     printf("*** unknown scsi cmd %02X ***\n", atapi_p.cdb.CDB12.OperationCode);
  1044.  
  1045.     reg.err = 0;
  1046.     state = S_IDLE;
  1047.     reg.status = STATUS_DSC | STATUS_ERR | STATUS_DRDY;
  1048. }
  1049.  
  1050. void ATA_DEVICE::handle_atapi_packet()
  1051. {
  1052. #if defined(DUMP_HDD_IO)
  1053.    {
  1054.        printf(" [packet");
  1055.        for (int i = 0; i < 12; i++)
  1056.            printf("-%02X", transbf[i]);
  1057.        printf("]\n");
  1058.    }
  1059. #endif
  1060.    if(phys_dev == -1U)
  1061.        return handle_atapi_packet_emulate();
  1062.  
  1063.    memcpy(&atapi_p.cdb, transbf, 12);
  1064.  
  1065.    intrq = 1;
  1066.  
  1067.    if (atapi_p.cdb.MODE_SELECT10.OperationCode == 0x55)
  1068.    { // MODE SELECT requires additional data from host
  1069.  
  1070.       state = S_MODE_SELECT;
  1071.       reg.status = STATUS_DRQ;
  1072.       reg.intreason = 0;
  1073.       transptr = 0;
  1074.       transcount = atapi_p.cdb.MODE_SELECT10.ParameterListLength[0]*0x100 + atapi_p.cdb.MODE_SELECT10.ParameterListLength[1];
  1075.       return;
  1076.    }
  1077.  
  1078.    if (atapi_p.cdb.CDB6READWRITE.OperationCode == 0x03 && atapi_p.senselen)
  1079.    { // REQ.SENSE - read cached
  1080.       memcpy(transbf, atapi_p.sense, atapi_p.senselen);
  1081.       atapi_p.passed_length = atapi_p.senselen; atapi_p.senselen = 0; // next time read from device
  1082.       goto ok;
  1083.    }
  1084.  
  1085.    if (atapi_p.pass_through(transbf, sizeof transbf))
  1086.    {
  1087.       if (atapi_p.senselen)
  1088.       {
  1089.           reg.err = u8(atapi_p.sense[2] << 4);
  1090.           goto err;
  1091.       } // err = sense key //win9x hangs on drq after atapi packet when emulator does goto err (see walkaround in SEND_ASPI_CMD)
  1092.     ok:
  1093.       if (!atapi_p.cdb.CDB6READWRITE.OperationCode)
  1094.           atapi_p.passed_length = 0; // bugfix in cdrom driver: TEST UNIT READY has no data
  1095.       if (!atapi_p.passed_length /* || atapi_p.passed_length == sizeof transbf */ )
  1096.       {
  1097.           command_ok();
  1098.           return;
  1099.       }
  1100.       reg.atapi_count = u16(atapi_p.passed_length);
  1101.       reg.intreason = INT_IO;
  1102.       reg.status = STATUS_DRQ;
  1103.       transcount = (atapi_p.passed_length+1)/2;
  1104.           //printf("transcount=%d\n",transcount); //32768 in win9x
  1105.       transptr = 0;
  1106.       state = S_READ_ATAPI;
  1107.    }
  1108.    else
  1109.    { // bus error
  1110.       reg.err = 0;
  1111.     err:
  1112.       state = S_IDLE;
  1113.       reg.status = STATUS_DSC | STATUS_ERR | STATUS_DRDY;
  1114.    }
  1115. }
  1116.  
  1117. void ATA_DEVICE::prepare_id()
  1118. {
  1119.    if (phys_dev == -1U)
  1120.    {
  1121.       memset(transbf, 0, 512);
  1122.       make_ata_string(transbf+54, 20, "UNREAL SPECCY HARD DRIVE IMAGE");
  1123.       make_ata_string(transbf+20, 10, "0000");
  1124.       make_ata_string(transbf+46,  4, VERS_STRING);
  1125.       *(unsigned short*)transbf = 0x045A;
  1126.       ((unsigned short*)transbf)[1] = (unsigned short)c;
  1127.       ((unsigned short*)transbf)[3] = (unsigned short)h;
  1128.       ((unsigned short*)transbf)[6] = (unsigned short)s;
  1129.       *(unsigned*)(transbf+60*2) = (lba > 0xFFFFFFFULL) ? 0xFFFFFFF : unsigned(lba); // lba28
  1130.       ((unsigned short*)transbf)[20] = 3; // a dual ported multi-sector buffer capable of simultaneous transfers with a read caching capability
  1131.       ((unsigned short*)transbf)[21] = 512; // cache size=256k
  1132.       ((unsigned short*)transbf)[22] = 4; // ECC bytes
  1133.       ((unsigned short*)transbf)[49] = 0x200; // LBA supported
  1134.       ((unsigned short*)transbf)[80] = 0x3E; // support specifications up to ATA-5
  1135.       ((unsigned short*)transbf)[81] = 0x13; // ATA/ATAPI-5 T13 1321D revision 3
  1136.       ((unsigned short*)transbf)[82] = 0x60; // supported look-ahead and write cache
  1137.  
  1138.       if(lba > 0xFFFFFFFULL)
  1139.       {
  1140.           ((unsigned short*)transbf)[83] = 0x400; // lba48 supported
  1141.           ((unsigned short*)transbf)[86] = 0x400; // lba48 supported
  1142.           *(u64*)(transbf+100*2) = lba; // lba48
  1143.       }
  1144.  
  1145.       // make checksum
  1146.       transbf[510] = 0xA5;
  1147.       unsigned char cs = 0;
  1148.       for (unsigned i = 0; i < 511; i++)
  1149.           cs += transbf[i];
  1150.       transbf[511] = 0-cs;
  1151.    }
  1152.    else
  1153.    { // copy as is...
  1154.       memcpy(transbf, phys[phys_dev].idsector, 512);
  1155.    }
  1156.  
  1157.    state = S_READ_ID;
  1158.    transptr = 0;
  1159.    transcount = 0x100;
  1160.    intrq = 1;
  1161.    reg.status = STATUS_DRDY | STATUS_DRQ | STATUS_DSC;
  1162.    reg.err = 0;
  1163. }
  1164.  
  1165. void ATA_DEVICE::update_regs()
  1166. {
  1167. //printf("%s: cyl_before = %04x\n", __PRETTY_FUNCTION__, reg.cyl);
  1168.     if(atapi) return; // do not kill reg contents if ATAPI:
  1169.                       // needed to keep EB14 signature after
  1170.                       // IDENTIFY DEVICE issued for ATAPI device
  1171.  
  1172.    if(reg.devhead & 0x40)
  1173.    { // lba
  1174.        if(lba > 0xFFFFFFFULL)
  1175.        { // lba48
  1176.            reg.lba0 = lba_cur & 0xFF;
  1177.            reg.lba1 = (lba_cur >> 8) & 0xFF;
  1178.            reg.lba2 = (lba_cur >> 16) & 0xFF;
  1179.            reg.lba4 = (lba_cur >> 24) & 0xFF;
  1180.            reg.lba5 = (lba_cur >> 32) & 0xFF;
  1181.            reg.lba6 = (lba_cur >> 40) & 0xFF;
  1182.        }
  1183.        else
  1184.        { // lba28
  1185.            reg.lba0 = lba_cur & 0xFF;
  1186.            reg.lba1 = (lba_cur >> 8) & 0xFF;
  1187.            reg.lba2 = (lba_cur >> 16) & 0xFF;
  1188.            reg.lba3 &= ~0xF;
  1189.            reg.lba3 |= (lba_cur >> 24) & 0xF;
  1190.        }
  1191.    }
  1192.    else
  1193.    { // chs
  1194.        reg.cyl = u16(c_cur);
  1195.        reg.devhead &= ~0xF;
  1196.        reg.devhead |= h_cur & 0xF;
  1197.        reg.sec = u8(s_cur);
  1198.    }
  1199. //printf("%s: cyl_after = %04x\n", __PRETTY_FUNCTION__, reg.cyl);
  1200. }
  1201.  
  1202. void ATA_DEVICE::update_cur()
  1203. {
  1204.    n_cur = reg.count;
  1205.    if(lba > 0xFFFFFFFULL)
  1206.    { // lba48
  1207.        lba_cur = reg.lba0 | (u64(reg.lba1) << 8) | (u64(reg.lba2) << 16) | (u64(reg.lba4) << 24) | (u64(reg.lba5) << 32) | (u64(reg.lba6) << 40);
  1208.        n_cur |= unsigned(reg.count1 << 8);
  1209.    }
  1210.    else
  1211.    { // lba28
  1212.        lba_cur = reg.lba0 | (u64(reg.lba1) << 8) | (u64(reg.lba2) << 16) | (u64(reg.lba3 & 0xF) << 24);
  1213.    }
  1214.  
  1215.    c_cur = reg.cyl;
  1216.    h_cur = reg.devhead & 0xF;
  1217.    s_cur = reg.sec;
  1218. }
  1219.