Previous 199869 Revisions Next

r30929 Tuesday 10th June, 2014 at 22:03:18 UTC by Carl
upd765: implement scan data and read track [Carl]
       fail command when drive not ready and check ready before command (verified on real hardware)
       stop polling when first byte of command sent (verified)

(mess) x68k: experiment with fdc drive control (nw)
[src/emu/machine]hd63450.c upd765.c upd765.h
[src/mess/drivers]x68k.c
[src/mess/includes]x68k.h
[src/mess/video]x68k.c

trunk/src/emu/machine/hd63450.c
r30928r30929
274274
275275TIMER_CALLBACK_MEMBER(hd63450_device::dma_transfer_timer)
276276{
277   if((m_reg[param].ocr & 3) == 2)
277   if(((m_reg[param].ocr & 3) == 2) && !m_drq_state[param])
278278      return;
279279   single_transfer(param);
280280}
r30928r30929
467467               m_reg[x].mtc = space.read_word(m_reg[x].bar+4);
468468               return;
469469            }
470            m_timer[x]->adjust(attotime::zero);
470            m_timer[x]->adjust(attotime::never);
471471            m_in_progress[x] = 0;
472472            m_reg[x].csr |= 0xe0;  // channel operation complete, block transfer complete
473473            m_reg[x].csr &= ~0x08;  // channel no longer active
r30928r30929
491491   m_drq_state[0] = state;
492492   
493493   if((m_reg[0].ocr & 2) && (state && !ostate))
494   {
495      // in cycle steal mode drq is supposed to be edge triggered
494496      single_transfer(0);
497      m_timer[0]->adjust(m_our_clock[0], 0, m_our_clock[0]);
498   }
499   else if(!state)
500      m_timer[0]->adjust(attotime::never);
495501}
496502
497503WRITE_LINE_MEMBER(hd63450_device::drq1_w)
r30928r30929
500506   m_drq_state[1] = state;
501507
502508   if((m_reg[1].ocr & 2) && (state && !ostate))
509   {
503510      single_transfer(1);
511      m_timer[1]->adjust(m_our_clock[1], 1, m_our_clock[1]);
512   }
513   else if(!state)
514      m_timer[1]->adjust(attotime::never);
504515}
505516
506517WRITE_LINE_MEMBER(hd63450_device::drq2_w)
r30928r30929
509520   m_drq_state[2] = state;
510521   
511522   if((m_reg[2].ocr & 2) && (state && !ostate))
523   {
512524      single_transfer(2);
525      m_timer[0]->adjust(m_our_clock[2], 2, m_our_clock[2]);
526   }
527   else if(!state)
528      m_timer[2]->adjust(attotime::never);
513529}
514530
515531WRITE_LINE_MEMBER(hd63450_device::drq3_w)
r30928r30929
518534   m_drq_state[3] = state;
519535   
520536   if((m_reg[3].ocr & 2) && (state && !ostate))
537   {
521538      single_transfer(3);
539      m_timer[0]->adjust(m_our_clock[3], 3, m_our_clock[3]);
540   }
541   else if(!state)
542      m_timer[3]->adjust(attotime::never);
522543}
523544
524545int hd63450_device::get_vector(int channel)
trunk/src/emu/machine/upd765.c
r30928r30929
116116   ready_connected = true;
117117   select_connected = true;
118118   external_ready = false;
119   no_poll_irq = false;
120119   dor_reset = 0x00;
121120   mode = MODE_AT;
122121}
r30928r30929
845844         int slot = (cur_live.bit_counter >> 4)-1;
846845         if(slot < sector_size) {
847846            // Sector data
848            live_delay(READ_SECTOR_DATA_BYTE);
847            if(cur_live.fi->main_state == SCAN_DATA)
848               live_delay(SCAN_SECTOR_DATA_BYTE);
849            else
850               live_delay(READ_SECTOR_DATA_BYTE);
849851            return;
850852
851853         } else if(slot < sector_size+2) {
r30928r30929
865867         checkpoint();
866868         break;
867869
870      case SCAN_SECTOR_DATA_BYTE:
871         if(!scan_done) // TODO: handle stp, x68000 sets it to 0xff (as it would dtl)?
872         {
873            int slot = (cur_live.bit_counter >> 4)-1;
874            UINT8 data = fifo_pop(true);
875            if(!slot)
876               st2 = (st2 & ~(ST2_SN)) | ST2_SH;
877
878            if(data != cur_live.data_reg)
879            {
880               st2 = (st2 & ~(ST2_SH)) | ST2_SN;
881               if((data < cur_live.data_reg) && ((command[0] & 0x1f) == 0x19)) // low
882                  st2 &= ~ST2_SN;
883
884               if((data > cur_live.data_reg) && ((command[0] & 0x1f) == 0x1d)) // high
885                  st2 &= ~ST2_SN;
886            }
887            if((slot == sector_size) && !(st2 & ST2_SN))
888            {
889               scan_done = true;
890               tc_done = true;
891            }
892         }
893         else
894         {
895            if(fifo_pos)
896               fifo_pop(true);
897         }
898         cur_live.state = READ_SECTOR_DATA;
899         checkpoint();
900         break;
901
868902      case WRITE_SECTOR_SKIP_GAP2:
869903         cur_live.bit_counter = 0;
870904         cur_live.byte_counter = 0;
r30928r30929
11501184   case 0x0f:
11511185      return command_pos == 3 ? C_SEEK               : C_INCOMPLETE;
11521186
1187   case 0x11:
1188      return command_pos == 9 ? C_SCAN_EQUAL         : C_INCOMPLETE;
1189
11531190   case 0x12:
11541191      return command_pos == 2 ? C_PERPENDICULAR      : C_INCOMPLETE;
11551192
r30928r30929
11591196   case 0x14:
11601197      return C_LOCK;
11611198
1199   case 0x19:
1200      return command_pos == 9 ? C_SCAN_LOW           : C_INCOMPLETE;
1201
1202   case 0x1d:
1203      return command_pos == 9 ? C_SCAN_HIGH          : C_INCOMPLETE;
1204
11621205   default:
11631206      return C_INVALID;
11641207   }
r30928r30929
12281271      read_track_start(flopi[command[1] & 3]);
12291272      break;
12301273
1274   case C_SCAN_EQUAL:
1275   case C_SCAN_LOW:
1276   case C_SCAN_HIGH:
1277      scan_start(flopi[command[1] & 3]);
1278      break;
1279
12311280   case C_RECALIBRATE:
12321281      recalibrate_start(flopi[command[1] & 3]);
12331282      main_phase = PHASE_CMD;
r30928r30929
14481497   fi.st0 = command[1] & 7;
14491498   st1 = ST1_MA;
14501499   st2 = 0x00;
1500   hdl_cb(1);
1501   fi.ready = get_ready(command[1] & 3);
14511502
1503   if(!fi.ready)
1504   {
1505      fi.st0 |= ST0_NR | ST0_FAIL;
1506      fi.sub_state = COMMAND_DONE;
1507      st1 = 0;
1508      st2 = 0;
1509      read_data_continue(fi);
1510      return;
1511   }
1512
14521513   if(fi.dev)
14531514      fi.dev->ss_w(command[1] & 4 ? 1 : 0);
1515   read_data_continue(fi);
1516}
1517
1518void upd765_family_device::scan_start(floppy_info &fi)
1519{
1520   fi.main_state = SCAN_DATA;
1521   fi.sub_state = HEAD_LOAD_DONE;
1522   mfm = command[0] & 0x40;
1523
1524   logerror("%s: command scan%s data%s%s%s%s cmd=%02x sel=%x chrn=(%d, %d, %d, %d) eot=%02x gpl=%02x stp=%02x rate=%d\n",
1525            tag(),
1526            command[0] & 0x08 ? " deleted" : "",
1527            command[0] & 0x80 ? " mt" : "",
1528            command[0] & 0x40 ? " mfm" : "",
1529            command[0] & 0x20 ? " sk" : "",
1530            fifocfg & 0x40 ? " seek" : "",
1531            command[0],
1532            command[1],
1533            command[2],
1534            command[3],
1535            command[4],
1536            128 << (command[5] & 7),
1537            command[6],
1538            command[7],
1539            command[8],
1540            cur_rate);
1541
1542   fi.st0 = command[1] & 7;
1543   st1 = ST1_MA;
1544   st2 = 0x00;
1545   scan_done = false;
14541546   hdl_cb(1);
1547   fi.ready = get_ready(command[1] & 3);
1548
1549   if(!fi.ready)
1550   {
1551      fi.st0 |= ST0_NR | ST0_FAIL;
1552      fi.sub_state = COMMAND_DONE;
1553      st1 = 0;
1554      st2 = 0;
1555      read_data_continue(fi);
1556      return;
1557   }
1558
1559   if(fi.dev)
1560      fi.dev->ss_w(command[1] & 4 ? 1 : 0);
14551561   read_data_continue(fi);
14561562}
14571563
r30928r30929
15291635                  cur_live.idbuf[2],
15301636                  cur_live.idbuf[3]);
15311637         sector_size = calc_sector_size(cur_live.idbuf[3]);
1532         fifo_expect(sector_size, false);
1638         if(fi.main_state == SCAN_DATA)
1639            fifo_expect(sector_size, true);
1640         else
1641            fifo_expect(sector_size, false);
15331642         fi.sub_state = SECTOR_READ;
15341643         live_start(fi, SEARCH_ADDRESS_MARK_DATA);
15351644         return;
r30928r30929
16281737   fi.st0 = command[1] & 7;
16291738   st1 = ST1_MA;
16301739   st2 = 0x00;
1740   hdl_cb(1);
1741   fi.ready = get_ready(command[1] & 3);
16311742
1632   hdl_cb(1);
1743   if(!fi.ready)
1744   {
1745      fi.st0 |= ST0_NR | ST0_FAIL;
1746      fi.sub_state = COMMAND_DONE;
1747      st1 = 0;
1748      st2 = 0;
1749      write_data_continue(fi);
1750      return;
1751   }
1752
16331753   write_data_continue(fi);
16341754}
16351755
r30928r30929
17211841   fi.main_state = READ_TRACK;
17221842   fi.sub_state = HEAD_LOAD_DONE;
17231843   mfm = command[0] & 0x40;
1844   sectors_read = 0;
17241845
17251846   logerror("%s: command read track%s cmd=%02x sel=%x chrn=(%d, %d, %d, %d) eot=%02x gpl=%02x dtl=%02x rate=%d\n",
17261847            tag(),
r30928r30929
17351856            command[7],
17361857            command[8],
17371858            cur_rate);
1859   fi.st0 = command[1] & 7;
1860   st1 = ST1_MA;
1861   st2 = 0x00;
1862   hdl_cb(1);
1863   fi.ready = get_ready(command[1] & 3);
17381864
1865   if(!fi.ready)
1866   {
1867      fi.st0 |= ST0_NR | ST0_FAIL;
1868      fi.sub_state = COMMAND_DONE;
1869      st1 = 0;
1870      st2 = 0;
1871      read_track_continue(fi);
1872      return;
1873   }
1874
17391875   if(fi.dev)
17401876      fi.dev->ss_w(command[1] & 4 ? 1 : 0);
1741   hdl_cb(1);
17421877   read_track_continue(fi);
17431878}
17441879
r30928r30929
17511886            fi.sub_state = SEEK_DONE;
17521887            break;
17531888         }
1889         fi.st0 |= ST0_SE;
17541890         if(fi.dev) {
17551891            fi.dev->dir_w(fi.pcn > command[2] ? 1 : 0);
17561892            fi.dev->stp_w(0);
r30928r30929
17831919
17841920      case SEEK_DONE:
17851921         fi.counter = 0;
1922         fi.sub_state = WAIT_INDEX;
1923         return;
1924
1925      case WAIT_INDEX:
1926         return;
1927
1928      case WAIT_INDEX_DONE:
1929         logerror("%s: index found, reading track\n", tag());
17861930         fi.sub_state = SCAN_ID;
17871931         live_start(fi, SEARCH_ADDRESS_MARK_HEADER);
17881932         return;
17891933
17901934      case SCAN_ID:
17911935         if(cur_live.crc) {
1792            fprintf(stderr, "Header CRC error\n");
1793            live_start(fi, SEARCH_ADDRESS_MARK_HEADER);
1794            return;
1936            st1 |= ST1_DE;
17951937         }
1938         st1 &= ~ST1_MA;
1939         logerror("%s: reading sector %02x %02x %02x %02x\n",
1940                  tag(),
1941                  cur_live.idbuf[0],
1942                  cur_live.idbuf[1],
1943                  cur_live.idbuf[2],
1944                  cur_live.idbuf[3]);
1945         if(!sector_matches())
1946            st1 |= ST1_ND;
1947         else
1948            st1 &= ~ST1_ND;
1949
17961950         sector_size = calc_sector_size(cur_live.idbuf[3]);
17971951         fifo_expect(sector_size, false);
17981952         fi.sub_state = SECTOR_READ;
r30928r30929
18001954         return;
18011955
18021956      case SCAN_ID_FAILED:
1803         fprintf(stderr, "RNF\n");
1804         //          command_end(fi, true, 1);
1805         return;
1957         fi.st0 |= ST0_FAIL;
1958         st1 |= ST1_ND;
1959         fi.sub_state = COMMAND_DONE;
1960         break;
18061961
1807      case SECTOR_READ:
1962      case SECTOR_READ: {
1963         if(st2 & ST2_MD) {
1964            fi.st0 |= ST0_FAIL;
1965            fi.sub_state = COMMAND_DONE;
1966            break;
1967         }
18081968         if(cur_live.crc) {
1809            fprintf(stderr, "CRC error\n");
1969            st1 |= ST1_DE;
1970            st2 |= ST2_CM;
18101971         }
1811         if(command[4] < command[6]) {
1812            command[4]++;
1813            fi.sub_state = HEAD_LOAD_DONE;
1972         bool done = tc_done;
1973         sectors_read++;
1974         if(sectors_read == command[6]) {
1975            if(!tc_done) {
1976               fi.st0 |= ST0_FAIL;
1977               st1 |= ST1_EN;
1978            }
1979            done = true;
1980         }
1981         if(!done) {
1982            fi.sub_state = WAIT_INDEX_DONE;
18141983            break;
18151984         }
1985         fi.sub_state = COMMAND_DONE;
1986         break;
1987      }
18161988
1989      case COMMAND_DONE:
18171990         main_phase = PHASE_RESULT;
1818         result[0] = 0x40 | (fi.dev->ss_r() << 2) | fi.id;
1819         result[1] = 0;
1820         result[2] = 0;
1991         result[0] = fi.st0;
1992         result[1] = st1;
1993         result[2] = st2;
18211994         result[3] = command[2];
18221995         result[4] = command[3];
18231996         result[5] = command[4];
18241997         result[6] = command[5];
18251998         result_pos = 7;
1826         //          command_end(fi, true, 0);
1999         command_end(fi, true);
18272000         return;
18282001
18292002      default:
r30928r30929
18492022            command[0] & 0x40 ? "mfm" : "fm",
18502023            command[1], command[2], command[3], command[4], command[5]);
18512024
2025   hdl_cb(1);
2026   fi.ready = get_ready(command[1] & 3);
2027
2028   if(!fi.ready)
2029   {
2030      fi.st0 = (command[1] & 7) | ST0_NR | ST0_FAIL;
2031      fi.sub_state = TRACK_DONE;
2032      format_track_continue(fi);
2033      return;
2034   }
2035   fi.st0 = command[1] & 7;
2036
18522037   if(fi.dev)
18532038      fi.dev->ss_w(command[1] & 4 ? 1 : 0);
18542039   sector_size = calc_sector_size(command[2]);
18552040
1856   hdl_cb(1);
18572041   format_track_continue(fi);
18582042}
18592043
r30928r30929
18772061
18782062      case TRACK_DONE:
18792063         main_phase = PHASE_RESULT;
1880         result[0] = (fi.dev->ss_r() << 2) | fi.id;
2064         result[0] = fi.st0;
18812065         result[1] = 0;
18822066         result[2] = 0;
18832067         result[3] = 0;
r30928r30929
19172101      cur_live.idbuf[i] = 0x00;
19182102
19192103   hdl_cb(1);
2104   fi.ready = get_ready(command[1] & 3);
2105
2106   if(!fi.ready)
2107   {
2108      fi.st0 |= ST0_NR | ST0_FAIL;
2109      fi.sub_state = COMMAND_DONE;
2110      read_id_continue(fi);
2111      return;
2112   }
2113
19202114   read_id_continue(fi);
19212115}
19222116
r30928r30929
20222216
20232217void upd765_family_device::run_drive_ready_polling()
20242218{
2025   if(main_phase != PHASE_CMD || (fifocfg & FIF_POLL))
2219   if(main_phase != PHASE_CMD || (fifocfg & FIF_POLL) || command_pos)
20262220      return;
20272221
20282222   for(int fid=0; fid<4; fid++) {
r30928r30929
20332227         if(!flopi[fid].st0_filled) {
20342228            flopi[fid].st0 = ST0_ABRT | fid;
20352229            flopi[fid].st0_filled = true;
2036            if(!no_poll_irq)
2037               other_irq = true;
2230            other_irq = true;
20382231         }
20392232      }
20402233   }
r30928r30929
21142307      break;
21152308
21162309   case READ_DATA:
2310   case SCAN_DATA:
21172311      read_data_continue(fi);
21182312      break;
21192313
r30928r30929
22412435upd72065_device::upd72065_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : upd765_family_device(mconfig, UPD72065, "UPD72065", tag, owner, clock, "upd72065", __FILE__)
22422436{
22432437   dor_reset = 0x0c;
2244   no_poll_irq = true;
22452438}
22462439
22472440smc37c78_device::smc37c78_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : upd765_family_device(mconfig, SMC37C78, "SMC37C78", tag, owner, clock, "smc37c78", __FILE__)
trunk/src/emu/machine/upd765.h
r30928r30929
207207      READ_TRACK,
208208      FORMAT_TRACK,
209209      READ_ID,
210      SCAN_DATA,
210211
211212      // Sub-states
212213      COMMAND_DONE,
r30928r30929
241242      SEARCH_ADDRESS_MARK_DATA_FAILED,
242243      READ_SECTOR_DATA,
243244      READ_SECTOR_DATA_BYTE,
245      SCAN_SECTOR_DATA_BYTE,
244246
245247      WRITE_SECTOR_SKIP_GAP2,
246248      WRITE_SECTOR_SKIP_GAP2_BYTE,
r30928r30929
305307
306308   bool ready_connected, ready_polled, select_connected;
307309
308   bool external_ready, no_poll_irq;
310   bool external_ready;
309311
310312   int mode;
311313   int main_phase;
312314
313315   live_info cur_live, checkpoint_live;
314316   devcb_write_line intrq_cb, drq_cb, hdl_cb;
315   bool cur_irq, other_irq, data_irq, drq, internal_drq, tc, tc_done, locked, mfm;
317   bool cur_irq, other_irq, data_irq, drq, internal_drq, tc, tc_done, locked, mfm, scan_done;
316318   floppy_info flopi[4];
317319
318   int fifo_pos, fifo_expected, command_pos, result_pos;
320   int fifo_pos, fifo_expected, command_pos, result_pos, sectors_read;
319321   bool fifo_write;
320322   UINT8 dor, dsr, msr, fifo[16], command[16], result[16];
321323   UINT8 st1, st2, st3;
r30928r30929
345347      C_SENSE_INTERRUPT_STATUS,
346348      C_SPECIFY,
347349      C_WRITE_DATA,
350      C_SCAN_EQUAL,
351      C_SCAN_LOW,
352      C_SCAN_HIGH,
348353
349354      C_INVALID,
350355      C_INCOMPLETE,
r30928r30929
387392   void read_id_start(floppy_info &fi);
388393   void read_id_continue(floppy_info &fi);
389394
395   void scan_start(floppy_info &fi);
396
390397   void general_continue(floppy_info &fi);
391398   void index_callback(floppy_image_device *floppy, int state);
392399   bool sector_matches() const;
trunk/src/mess/includes/x68k.h
r30928r30929
6161         m_ym2151(*this, "ym2151"),
6262         m_ppi(*this, "ppi8255"),
6363         m_screen(*this, "screen"),
64         m_upd72065(*this, "upd72065"),
6465         m_options(*this, "options"),
6566         m_mouse1(*this, "mouse1"),
6667         m_mouse2(*this, "mouse2"),
r30928r30929
9192   required_device<ym2151_device> m_ym2151;
9293   required_device<i8255_device> m_ppi;
9394   required_device<screen_device> m_screen;
95   required_device<upd72065_device> m_upd72065;
9496
9597   required_ioport m_options;
9698   required_ioport m_mouse1;
r30928r30929
112114   bitmap_ind16 *m_pcgbitmap;
113115   bitmap_ind16 *m_gfxbitmap;
114116
115   void floppy_load_unload();
117   void floppy_load_unload(bool load, floppy_image_device *dev);
116118   int floppy_load(floppy_image_device *dev);
117119   void floppy_unload(floppy_image_device *dev);
118120   DECLARE_FLOPPY_FORMATS( floppy_formats );
r30928r30929
127129   } m_sysport;
128130   struct
129131   {
130      upd72065_device *fdc;
131132      floppy_image_device *floppy[4];
132133      int led_ctrl[4];
133134      int led_eject[4];
134135      int eject[4];
135      int motor[4];
136      int selected_drive;
136      int motor;
137      int control_drives;
138      int select_drive;
137139   } m_fdc;
138140   struct
139141   {
r30928r30929
283285   void dma_irq(int channel);
284286   DECLARE_WRITE8_MEMBER(dma_end);
285287   DECLARE_WRITE8_MEMBER(dma_error);
286   DECLARE_READ8_MEMBER(fdc_read_byte);
287   DECLARE_WRITE8_MEMBER(fdc_write_byte);
288288
289289   int x68k_read_mouse();
290290   void x68k_set_adpcm();
trunk/src/mess/video/x68k.c
r30928r30929
733733            + (((m_tvram[loc+0x20000] >> bit) & 0x01) ? 4 : 0)
734734            + (((m_tvram[loc+0x30000] >> bit) & 0x01) ? 8 : 0);
735735         // Colour 0 is displayable if the text layer is at the priority level 2
736         if((colour && (m_pcgpalette->pen(colour) & 0xffffff)) || ((m_video.reg[1] & 0x0c00) == 0x0800))
736         if((m_pcgpalette->pen(colour) & 0xffffff) || ((m_video.reg[1] & 0x0c00) == 0x0800))
737737            bitmap.pix32(line, pixel) = m_pcgpalette->pen(colour);
738738         bit--;
739739         if(bit < 0)
trunk/src/mess/drivers/x68k.c
r30928r30929
174174      x68k_crtc_vblank_irq(ptr, param);
175175      break;
176176   case TIMER_X68K_FDC_TC:
177      m_fdc.fdc->tc_w(ASSERT_LINE);
178      m_fdc.fdc->tc_w(CLEAR_LINE);
177      m_upd72065->tc_w(ASSERT_LINE);
178      m_upd72065->tc_w(CLEAR_LINE);
179179      break;
180180   case TIMER_X68K_ADPCM:
181181      m_hd63450->drq3_w(1);
r30928r30929
629629      x = data & 0x0f;
630630      for(drive=0;drive<4;drive++)
631631      {
632         if(m_fdc.selected_drive & (1 << drive))
632         if(m_fdc.control_drives & (1 << drive))
633633         {
634634            if(!(x & (1 << drive)))  // functions take place on 1->0 transitions of drive bits only
635635            {
636636               m_fdc.led_ctrl[drive] = data & 0x80;  // blinking drive LED if no disk inserted
637637               m_fdc.led_eject[drive] = data & 0x40;  // eject button LED (on when set to 0)
638638               output_set_indexed_value("eject_drv",drive,(data & 0x40) ? 1 : 0);
639               if(data & 0x20)  // ejects disk
640               {
641                  m_fdc.floppy[drive]->mon_w(true);
639               if((data & 0x60) == 0x20)  // ejects disk
642640                  m_fdc.floppy[drive]->unload();
643               }
644641            }
645642         }
646643      }
647      m_fdc.selected_drive = data & 0x0f;
644      m_fdc.control_drives = data & 0x0f;
648645      logerror("FDC: signal control set to %02x\n",data);
649646      break;
650647   case 0x01: {
651      static const int rates[4] = { 500000, 300000, 250000, 125000 };
652      m_fdc.fdc->set_rate(rates[(data >> 4) & 3]);
653      m_fdc.motor[data & 0x03] = data & 0x80;
654      m_fdc.floppy[data & 0x03]->mon_w(!BIT(data, 7));
655      if(data & 0x80)
656      {
657         for(drive=0;drive<4;drive++) // enable motor for this drive
658         {
659            if(drive == (data & 0x03))
660            {
661               m_fdc.floppy[drive]->mon_w(false);
662               output_set_indexed_value("access_drv",drive,0);
663            }
664            else
665               output_set_indexed_value("access_drv",drive,1);
666         }
667      }
668      else    // BIOS code suggests that setting bit 7 of this port to 0 disables the motor of all floppy drives
669      {
670         for(drive=0;drive<4;drive++)
671         {
672            m_fdc.floppy[drive]->mon_w(true);
673            output_set_indexed_value("access_drv",drive,1);
674         }
675      }
676      logerror("FDC: Drive #%i: Drive selection set to %02x\n",data & 0x03,data);
648      x = data & 3;
649      m_upd72065->set_floppy(m_fdc.floppy[x]);
650      m_upd72065->set_rate((data & 0x10) ? 300000 : 500000);
651      m_fdc.motor = data & 0x80;
652
653      for(int i = 0; i < 4; i++)
654         if(m_fdc.floppy[i]->exists())
655            m_fdc.floppy[i]->mon_w(!BIT(data, 7));
656
657      output_set_indexed_value("access_drv",x,0);
658      if(x != m_fdc.select_drive)
659         output_set_indexed_value("access_drv",m_fdc.select_drive,1);
660      m_fdc.select_drive = x;
661      logerror("FDC: Drive #%i: Drive selection set to %02x\n",x,data);
677662      break;
663      }
678664   }
679   }
680665}
681666
682667READ16_MEMBER(x68k_state::x68k_fdc_r)
r30928r30929
690675      ret = 0x00;
691676      for(x=0;x<4;x++)
692677      {
693         if(m_fdc.selected_drive & (1 << x))
678         if(m_fdc.control_drives & (1 << x))
694679         {
695680            ret = 0x00;
696681            if(m_fdc.floppy[x]->exists())
r30928r30929
722707   }
723708}
724709
725READ8_MEMBER(x68k_state::fdc_read_byte)
726{
727   return m_fdc.fdc->dma_r();
728}
729
730WRITE8_MEMBER(x68k_state::fdc_write_byte)
731{
732   return m_fdc.fdc->dma_w(data);
733}
734
735710WRITE16_MEMBER(x68k_state::x68k_fm_w)
736711{
737712   switch(offset)
r30928r30929
756731   // CT1 and CT2 bits from YM2151 port 0x1b
757732   // CT1 - ADPCM clock - 0 = 8MHz, 1 = 4MHz
758733   // CT2 - 1 = Set ready state of FDC
759   m_fdc.fdc->ready_w(data & 0x01);
734   if(data & 1)
735   {
736      m_upd72065->set_ready_line_connected(0);
737      m_upd72065->ready_w(0);
738   }
739   else
740      m_upd72065->set_ready_line_connected(1);
741
760742   m_adpcm.clock = data & 0x02;
761743   x68k_set_adpcm();
762744   m_okim6258->set_clock(data & 0x02 ? 4000000 : 8000000);
r30928r30929
14591441
14601442INPUT_PORTS_END
14611443
1462void x68k_state::floppy_load_unload()
1444void x68k_state::floppy_load_unload(bool load, floppy_image_device *dev)
14631445{
1446   dev->mon_w(m_fdc.motor && !load);
14641447   if(m_ioc.irqstatus & 0x02)
14651448   {
14661449      m_current_vector[1] = 0x61;
r30928r30929
14731456
14741457int x68k_state::floppy_load(floppy_image_device *dev)
14751458{
1476   floppy_load_unload();
1459   floppy_load_unload(true, dev);
14771460   return IMAGE_INIT_PASS;
14781461}
14791462
14801463void x68k_state::floppy_unload(floppy_image_device *dev)
14811464{
1482   floppy_load_unload();
1465   floppy_load_unload(false, dev);
14831466}
14841467
14851468TIMER_CALLBACK_MEMBER(x68k_state::x68k_net_irq)
r30928r30929
15641547      output_set_indexed_value("ctrl_drv",drive,1);
15651548      output_set_indexed_value("access_drv",drive,1);
15661549   }
1550   m_fdc.select_drive = 0;
15671551
15681552   // reset CPU
15691553   m_maincpu->reset();
r30928r30929
15841568   // start LED timer
15851569   m_led_timer->adjust(attotime::zero, 0, attotime::from_msec(400));
15861570
1587   // check for disks
1588   m_fdc.fdc = machine().device<upd72065_device>("upd72065");
1589
15901571   for(int drive=0;drive<4;drive++)
15911572   {
15921573      char devname[16];
15931574      sprintf(devname, "%d", drive);
1594      floppy_image_device *floppy = m_fdc.fdc->subdevice<floppy_connector>(devname)->get_device();
1575      floppy_image_device *floppy = m_upd72065->subdevice<floppy_connector>(devname)->get_device();
15951576      m_fdc.floppy[drive] = floppy;
15961577      if(floppy) {
15971578         floppy->setup_load_cb(floppy_image_device::load_cb(FUNC(x68k_state::floppy_load), this));
15981579         floppy->setup_unload_cb(floppy_image_device::unload_cb(FUNC(x68k_state::floppy_unload), this));
15991580      }
16001581   }
1582   m_fdc.motor = 0;
16011583}
16021584
16031585DRIVER_INIT_MEMBER(x68k_state,x68000)
r30928r30929
16961678
16971679   MCFG_DEVICE_ADD("hd63450", HD63450, 0)
16981680   MCFG_HD63450_CPU("maincpu")   // CPU - 68000
1699   MCFG_HD63450_CLOCKS(attotime::from_usec(32), attotime::from_nsec(450), attotime::from_usec(4), attotime::from_hz(15625/2))
1700   MCFG_HD63450_BURST_CLOCKS(attotime::from_usec(32), attotime::from_nsec(450), attotime::from_nsec(50), attotime::from_nsec(50))
1681   MCFG_HD63450_CLOCKS(attotime::from_usec(2), attotime::from_nsec(450), attotime::from_usec(4), attotime::from_hz(15625/2))
1682   MCFG_HD63450_BURST_CLOCKS(attotime::from_usec(2), attotime::from_nsec(450), attotime::from_nsec(50), attotime::from_nsec(50))
17011683   MCFG_HD63450_DMA_END_CB(WRITE8(x68k_state, dma_end))
17021684   MCFG_HD63450_DMA_ERROR_CB(WRITE8(x68k_state, dma_error))
1703   MCFG_HD63450_DMA_READ_0_CB(READ8(x68k_state, fdc_read_byte))
1704   MCFG_HD63450_DMA_WRITE_0_CB(WRITE8(x68k_state, fdc_write_byte))
1685   MCFG_HD63450_DMA_READ_0_CB(DEVREAD8("upd72065", upd72065_device, mdma_r))
1686   MCFG_HD63450_DMA_WRITE_0_CB(DEVWRITE8("upd72065", upd72065_device, mdma_w))
17051687
17061688   MCFG_DEVICE_ADD("scc", SCC8530, 5000000)
17071689
r30928r30929
17411723   MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.50)
17421724   MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.50)
17431725
1744   MCFG_UPD72065_ADD("upd72065", true, true)
1726   MCFG_UPD72065_ADD("upd72065", true, false)
17451727   MCFG_UPD765_INTRQ_CALLBACK(WRITELINE(x68k_state, fdc_irq))
17461728   MCFG_UPD765_DRQ_CALLBACK(DEVWRITELINE("hd63450", hd63450_device, drq0_w))
17471729   MCFG_FLOPPY_DRIVE_ADD("upd72065:0", x68k_floppies, "525hd", x68k_state::floppy_formats)

Previous 199869 Revisions Next

© 1997-2024 The MAME Team