Previous 199869 Revisions Next

r26161 Thursday 14th November, 2013 at 19:01:29 UTC by Jürgen Buchmüller
Improve logging in diablo_hd_device. Sectors are loaded and cached. No command from a2disk yet.
[/branches/alto2/src/emu/cpu/alto2]a2disk.c alto2.c alto2.h
[/branches/alto2/src/emu/machine]diablo_hd.c

branches/alto2/src/emu/machine/diablo_hd.c
r26160r26161
6363diablo_hd_device::diablo_hd_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) :
6464   device_t(mconfig, DIABLO_HD, "Diablo Disk", tag, owner, clock, "diablo_hd", __FILE__),
6565#if   DIABLO_DEBUG
66   m_log_level(9),
66   m_log_level(6),
6767#endif
6868   m_diablo31(true),
6969   m_unit(0),
r26160r26161
273273{
274274   /* If there's no drive, just reset the page number */
275275   if (!m_image) {
276      LOG_DRIVE((0,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => no image\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
276277      m_page = -1;
277278      return;
278279   }
279280   if (m_cylinder < 0 || m_cylinder >= DIABLO_CYLINDERS) {
280      LOG_DRIVE((9,"   DRIVE C/H/S:%d/%d/%d => invalid cylinder\n", m_cylinder, m_head, m_sector));
281      LOG_DRIVE((0,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => invalid cylinder\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
281282      m_page = -1;
282283      return;
283284   }
284285   if (m_head < 0 || m_head >= DIABLO_HEADS) {
285      LOG_DRIVE((9,"   DRIVE C/H/S:%d/%d/%d => invalid head\n", m_cylinder, m_head, m_sector));
286      LOG_DRIVE((0,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => invalid head\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
286287      m_page = -1;
287288      return;
288289   }
289290   if (m_sector < 0 || m_sector >= DIABLO_SPT) {
290      LOG_DRIVE((9,"   DRIVE C/H/S:%d/%d/%d => invalid sector\n", m_cylinder, m_head, m_sector));
291      LOG_DRIVE((0,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => invalid sector\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
291292      m_page = -1;
292293      return;
293294   }
294295   /* calculate the new disk relative sector offset */
295296   m_page = DRIVE_PAGE(m_cylinder, m_head, m_sector);
296   LOG_DRIVE((9,"   DRIVE C/H/S:%d/%d/%d => page:%d\n", m_cylinder, m_head, m_sector, m_page));
297297
298298   // already have the sector image?
299   if (m_cache[m_page])
299   if (m_cache[m_page]) {
300      LOG_DRIVE((6,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => page:%d is cached\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, m_page));
300301      return;
302   }
301303
302304   /* allocate a buffer for this page */
303305   m_cache[m_page] = global_alloc_array(UINT8, sizeof(diablo_sector_t));
304306   /* and read the page from the hard_disk image */
305   if (!hard_disk_read(m_disk, m_page, m_cache[m_page])) {
306      LOG_DRIVE((0,"   read failed for #%d page #%d\n", m_unit, m_page));
307   if (hard_disk_read(m_disk, m_page, m_cache[m_page])) {
308      LOG_DRIVE((2,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => page:%d loaded\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, m_page));
309   } else {
310      LOG_DRIVE((0,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d => page:%d read failed\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, m_page));
307311      global_free(m_cache[m_page]);
308312      m_cache[m_page] = 0;
309      return;
310313   }
311314}
312315
r26160r26161
422425
423426   /* allocate a sector buffer */
424427   if (!m_cache[m_page]) {
425      LOG_DRIVE((0,"   no image for #%d page #%d\n", m_unit, m_page));
428      LOG_DRIVE((0,"[DHD]   %s: no image for #%d page #%d\n", __FUNCTION__, m_unit, m_page));
426429      return NULL;
427430   }
428431   diablo_sector_t *s = reinterpret_cast<diablo_sector_t *>(m_cache[m_page]);
r26160r26161
469472   }
470473   m_bits[m_page] = bits;
471474
472   LOG_DRIVE((0,"   BITS #%d: %03d/%d/%02d #%-5d bits (@%03d.%02d)\n",
473      m_unit, m_cylinder, m_head, m_sector,
474      dst, dst / 32, dst % 32));
475   LOG_DRIVE((0,"[DHD]   %s: BITS #%d: %03d/%d/%02d #%-5d bits (@%03d.%02d)\n",
476      __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, dst, dst / 32, dst % 32));
475477
476478   return bits;
477479}
r26160r26161
554556      }
555557   }
556558   /* return if no sync found within size*32 clock and data bits */
557   LOG_DRIVE((0,"   no sync within %d words\n", size));
559   LOG_DRIVE((0,"[DHD]   %s: no sync within %d words\n", __FUNCTION__, size));
558560   return src;
559561}
560562
r26160r26161
589591      }
590592   }
591593   /* return if no sync found within size*32 clock and data bits */
592   LOG_DRIVE((0,"   no unsync within %d words\n", size));
594   LOG_DRIVE((0,"[DHD]   %s: no unsync within %d words\n", __FUNCTION__, size));
593595   return src;
594596}
595597
r26160r26161
662664   int cksum_header, cksum_label, cksum_data;
663665
664666   if (m_rdfirst >= 0) {
665      LOG_DRIVE((0,
666         "   RD #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
667         m_unit, m_cylinder, m_head, m_sector,
667      LOG_DRIVE((0, "[DHD]   %s: RD #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
668         __FUNCTION__, m_unit, m_cylinder, m_head, m_sector,
668669         m_rdfirst, m_rdfirst / 32, m_rdfirst % 32,
669670         m_rdlast, m_rdlast / 32, m_rdlast % 32));
670671   }
r26160r26161
686687   }
687688
688689   if (m_wrfirst >= 0) {
689      LOG_DRIVE((0,
690         "   WR #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
691         m_unit, m_cylinder, m_head, m_sector,
690      LOG_DRIVE((0, "[DHD]   %s: WR #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
691         __FUNCTION__, m_unit, m_cylinder, m_head, m_sector,
692692         m_wrfirst, m_wrfirst / 32, m_wrfirst % 32,
693693         m_wrlast, m_wrlast / 32, m_wrlast % 32));
694694   }
r26160r26161
696696   m_wrlast = -1;
697697
698698   if (m_page < 0 || m_page >= DIABLO_PAGES) {
699      LOG_DRIVE((0,"   no sector for #%d: %d/%d/%d\n", m_unit, m_cylinder, m_head, m_sector));
699      LOG_DRIVE((0,"[DHD]   %s: no sector for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
700700      return;
701701   }
702702
703703   if (!m_cache[m_page]) {
704      LOG_DRIVE((0,"   no image for #%d: %d/%d/%d\n", m_unit, m_cylinder, m_head, m_sector));
704      LOG_DRIVE((0,"[DHD]   %s: no image for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
705705      return;
706706   }
707707
708708   /* no bits to write? */
709709   if (!m_bits[m_page]) {
710      LOG_DRIVE((0,"   no bits for #%d: %d/%d/%d\n", m_unit, m_cylinder, m_head, m_sector));
710      LOG_DRIVE((0,"[DHD]   %s: no bits for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
711711      return;
712712   }
713713   UINT32 *bits = m_bits[m_page];
r26160r26161
723723   src = squeeze_unsync(bits, src, 40);
724724   /* sync on header preamble */
725725   src = squeeze_sync(bits, src, 40);
726   LOG_DRIVE((0,"   header sync bit #%d (@%03d.%02d)\n", src, src / 32, src % 32));
726   LOG_DRIVE((0,"[DHD]   %s: header sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
727727   src = squeeze_record(bits, src, s->header, sizeof(s->header));
728728   src = squeeze_cksum(bits, src, &cksum_header);
729729#if   DIABLO_DEBUG
r26160r26161
734734   src = squeeze_unsync(bits, src, 40);
735735   /* sync on label preamble */
736736   src = squeeze_sync(bits, src, 40);
737   LOG_DRIVE((0,"   label  sync bit #%d (@%03d.%02d)\n", src, src / 32, src % 32));
737   LOG_DRIVE((0,"[DHD]   %s: label  sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
738738   src = squeeze_record(bits, src, s->label, sizeof(s->label));
739739   src = squeeze_cksum(bits, src, &cksum_label);
740740#if   DIABLO_DEBUG
r26160r26161
745745   src = squeeze_unsync(bits, src, 40);
746746   /* sync on data preamble */
747747   src = squeeze_sync(bits, src, 40);
748   LOG_DRIVE((0,"   data   sync bit #%d (@%03d.%02d)\n", src, src / 32, src % 32));
748   LOG_DRIVE((0,"[DHD]   %s: data   sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
749749   src = squeeze_record(bits, src, s->data, sizeof(s->data));
750750   src = squeeze_cksum(bits, src, &cksum_data);
751751#if   DIABLO_DEBUG
r26160r26161
759759
760760   if (cksum_header || cksum_label || cksum_data) {
761761#if   DIABLO_DEBUG
762      LOG_DRIVE((0,"   cksum check - header:%06o label:%06o data:%06o\n", cksum_header, cksum_label, cksum_data));
763#else
764      printf("   cksum check - header:%06o label:%06o data:%06o\n", cksum_header, cksum_label, cksum_data);
762      LOG_DRIVE((0,"[DHD]   %s: cksum check - header:%06o label:%06o data:%06o\n", __FUNCTION__, cksum_header, cksum_label, cksum_data));
765763#endif
766764   }
767765   global_free(m_bits[m_page]);
768766   m_bits[m_page] = 0;
769767
770768   if (!hard_disk_write(m_disk, m_page, m_cache[m_page])) {
771      LOG_DRIVE((0,"   write failed for #%d page #%d\n", m_unit, m_page));
769      LOG_DRIVE((0,"[DHD]   %s: write failed for #%d page #%d\n", __FUNCTION__, m_unit, m_page));
772770   }
773771}
774772
r26160r26161
964962      m_addx_acknowledge_0 = 0;
965963      /* clear log address interlock (?) */
966964      m_log_addx_interlock_0 = 1;
967      LOG_DRIVE((1,"   UNIT select %d ready\n", unit));
965      LOG_DRIVE((1,"[DHD]   %s: UNIT select %d ready\n", __FUNCTION__, unit));
968966   } else {
969967      /* it is not ready (?) */
970968      m_ready_0 = 1;
r26160r26161
972970      m_s_r_w_0 = 1;
973971      /* address acknowledge (?) */
974972      m_addx_acknowledge_0 = 0;
975      LOG_DRIVE((1,"   UNIT select %d not ready (no image)\n", unit));
973      LOG_DRIVE((1,"[DHD]   %s: UNIT select %d not ready (no image)\n", __FUNCTION__, unit));
976974   }
977975   read_sector();
978976}
r26160r26161
991989{
992990   int seekto = restore ? 0 : cylinder;
993991   if (strobe) {
994      LOG_DRIVE((1,"   STROBE end of interlock\n", seekto));
992      LOG_DRIVE((1,"[DHD]   %s: STROBE end of interlock\n", __FUNCTION__, seekto));
995993      /* deassert the log address interlock */
996994      m_log_addx_interlock_0 = 1;
997995      return;
r26160r26161
1001999   m_log_addx_interlock_0 = 0;
10021000
10031001   if (seekto == m_cylinder) {
1004      LOG_DRIVE((1,"   STROBE to cylinder %d acknowledge\n", seekto));
1002      LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d acknowledge\n", __FUNCTION__, seekto));
10051003      m_addx_acknowledge_0 = 0;   /* address acknowledge, if cylinder is reached */
10061004      m_seek_incomplete_0 = 1;   /* reset seek incomplete */
10071005      return;
r26160r26161
10171015         m_log_addx_interlock_0 = 1;   /* deassert the log address interlock */
10181016         m_seek_incomplete_0 = 1;   /* deassert seek incomplete */
10191017         m_addx_acknowledge_0 = 0;   /* assert address acknowledge  */
1020         LOG_DRIVE((1,"   STROBE to cylinder %d incomplete\n", seekto));
1018         LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d incomplete\n", __FUNCTION__, seekto));
10211019         return;
10221020      }
10231021   } else {
r26160r26161
10281026         m_log_addx_interlock_0 = 1;   /* deassert the log address interlock */
10291027         m_seek_incomplete_0 = 1;   /* deassert seek incomplete */
10301028         m_addx_acknowledge_0 = 0;   /* assert address acknowledge  */
1031         LOG_DRIVE((1,"   STROBE to cylinder %d incomplete\n", seekto));
1029         LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d incomplete\n", __FUNCTION__, seekto));
10321030         return;
10331031      }
10341032   }
1035   LOG_DRIVE((1,"   STROBE to cylinder %d (now %d) - interlock\n", seekto, m_cylinder));
1033   LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d (now %d) - interlock\n", __FUNCTION__, seekto, m_cylinder));
10361034
10371035   m_addx_acknowledge_0 = 1;   /* deassert address acknowledge  */
10381036   m_seek_incomplete_0 = 1;   /* deassert seek incomplete */
r26160r26161
11031101   if (-1 == m_wrfirst)
11041102      m_wrfirst = index;
11051103
1106   LOG_DRIVE((7,"   write #%d %d/%d/%d bit #%d bit:%d\n", m_unit, m_cylinder, m_head, m_sector, index, wrdata));
1104   LOG_DRIVE((7,"[DHD]   %s: write #%d %d/%d/%d bit #%d bit:%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, index, wrdata));
11071105
11081106   if (index < GUARD_ZONE_BITS) {
11091107      /* don't write in the guard zone (?) */
r26160r26161
11501148      m_rdfirst = index;
11511149
11521150   RDBIT(bits,index,bit);
1153   LOG_DRIVE((7,"   read #%d %d/%d/%d bit #%d:%d\n", m_unit, m_cylinder, m_head, m_sector, index, bit));
1151   LOG_DRIVE((7,"[DHD]   %s: read #%d %d/%d/%d bit #%d:%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, index, bit));
11541152   m_rdlast = index;
11551153   return bit;
11561154}
r26160r26161
11921190   } else {
11931191      RDBIT(bits,index,clk);
11941192   }
1195   LOG_DRIVE((7,   "   read #%d %d/%d/%d clk #%d:%d\n", m_unit, m_cylinder, m_head, m_sector, index, clk));
1193   LOG_DRIVE((7,"[DHD]   %s: read #%d %d/%d/%d clk #%d:%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, index, clk));
11961194   m_rdlast = index;
11971195   return clk ^ 1;
11981196}
r26160r26161
12031201 */
12041202void diablo_hd_device::sector_mark_1()
12051203{
1206   LOG_DRIVE((5, "   %s (unit #%d C/H/S:%d/%d/%d)\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
1204   LOG_DRIVE((9,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
12071205   /* set sector mark to 1 */
12081206   m_sector_mark_0 = 1;
12091207}
r26160r26161
12181216 */
12191217void diablo_hd_device::sector_mark_0()
12201218{
1221   LOG_DRIVE((5,"   %s (unit #%d C/H/S:%d/%d/%d)\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
1219   LOG_DRIVE((9,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
12221220
12231221   /* squeeze previous sector, if it was written to */
12241222   squeeze_sector();
r26160r26161
12331231
12341232   /* count sectors */
12351233   m_sector = (m_sector + 1) % DIABLO_SPT;
1234   /* read the sector */
12361235   read_sector();
12371236}
12381237
r26160r26161
12441243   m_packs = 1;      // FIXME: get from configuration?
12451244
12461245   m_cache = global_alloc_array(UINT8*, DIABLO_PAGES);
1246   memset(m_cache, 0, sizeof(UINT8*) * DIABLO_PAGES);
12471247   m_bits = global_alloc_array(UINT32*, DIABLO_PAGES);
1248   memset(m_bits, 0, sizeof(UINT32*) * DIABLO_PAGES);
12481249
12491250   m_timer = timer_alloc(1, 0);
12501251}
r26160r26161
12531254{
12541255   m_handle = m_image->get_chd_file();
12551256   m_disk = m_image->get_hard_disk_file();
1256   LOG_DRIVE((0,"[DIABLO] m_image=%p m_handle=%p m_disk=%p\n", m_image, m_handle, m_disk));
1257   LOG_DRIVE((0,"[DHD]   %s: m_image=%p m_handle=%p m_disk=%p\n", __FUNCTION__, m_image, m_handle, m_disk));
12571258
12581259   if (m_diablo31) {
12591260      snprintf(m_description, sizeof(m_description), "DIABLO31");
r26160r26161
12701271      m_sector_mark_1_time = DIABLO44_SECTOR_MARK_PULSE_PRE;
12711272      m_bit_time = DIABLO44_BIT_TIME(1);
12721273   }
1273   LOG_DRIVE((0,"[DIABLO] rotation time       : %.0fns\n", 1e9 * m_rotation_time.as_double()));
1274   LOG_DRIVE((0,"[DIABLO] sector time         : %.0fns\n", 1e9 * m_sector_time.as_double()));
1275   LOG_DRIVE((0,"[DIABLO] sector mark 0 time  : %.0fns\n", 1e9 * m_sector_mark_0_time.as_double()));
1276   LOG_DRIVE((0,"[DIABLO] sector mark 1 time  : %.0fns\n", 1e9 * m_sector_mark_1_time.as_double()));
1277   LOG_DRIVE((0,"[DIABLO] bit time            : %.0fns\n", 1e9 * m_bit_time.as_double()));
1274   LOG_DRIVE((0,"[DHD]   %s: rotation time       : %.0fns\n", __FUNCTION__, 1e9 * m_rotation_time.as_double()));
1275   LOG_DRIVE((0,"[DHD]   %s: sector time         : %.0fns\n", __FUNCTION__, 1e9 * m_sector_time.as_double()));
1276   LOG_DRIVE((0,"[DHD]   %s: sector mark 0 time  : %.0fns\n", __FUNCTION__, 1e9 * m_sector_mark_0_time.as_double()));
1277   LOG_DRIVE((0,"[DHD]   %s: sector mark 1 time  : %.0fns\n", __FUNCTION__, 1e9 * m_sector_mark_1_time.as_double()));
1278   LOG_DRIVE((0,"[DHD]   %s: bit time            : %.0fns\n", __FUNCTION__, 1e9 * m_bit_time.as_double()));
12781279
12791280   m_s_r_w_0 = 1;               /* seek/read/write not ready */
12801281   m_ready_0 = 1;               /* drive is not ready */
r26160r26161
12861287   /* reset the disk drive's address */
12871288   m_cylinder = 0;
12881289   m_head = 0;
1289   m_sector = 0;
1290   m_sector = DIABLO_SPT - 1;
12901291   m_page = -1;
12911292
12921293   /* disable the gates */
r26160r26161
13001301   m_rdfirst = -1;
13011302   m_rdlast = -1;
13021303
1303   timer_set(m_sector_time - m_sector_mark_0_time, 1, 0);
1304   if (m_handle)
1305      timer_set(m_sector_time - m_sector_mark_0_time, 1, 0);
13041306}
13051307
13061308/**
r26160r26161
13161318 */
13171319void diablo_hd_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
13181320{
1319   LOG_DRIVE((0,"[DIABLO] id=%d param=%d ptr=%p timer expires in %lldns\n", id, param, ptr));
1321   LOG_DRIVE((6,"[DHD]   %s: id=%d param=%d ptr=%p\n", __FUNCTION__, id, param, ptr));
13201322
13211323   switch (param) {
13221324   case 0:
branches/alto2/src/emu/cpu/alto2/a2disk.c
r26160r26161
22522252   if (++arg < bits) {
22532253      assert(dhd != NULL);
22542254      m_dsk.bitclk_timer->adjust(dhd->bit_time(), arg);
2255      m_dsk.bitclk_timer->enable();
22562255   }
22572256}
22582257
r26160r26161
22672266   LOG((LOG_DISK,0,"%s dhd=%p\n", __FUNCTION__, dhd));
22682267   if (m_dsk.bitclk_timer) {
22692268      LOG((LOG_DISK,0,"   unit #%d stop bitclk\n", m_dsk.bitclk));
2270      m_dsk.bitclk_timer->enable(false);
2269      m_dsk.bitclk_timer->reset();
22712270   }
22722271
22732272   /* KSTAT[0-3] update the current sector in the kstat field */
r26160r26161
22802279   LOG((LOG_DISK,1,"   unit #%d sector %d start\n", unit, GET_KSTAT_SECTOR(m_dsk.kstat)));
22812280
22822281   /* HACK: no command, no bit clock */
2283   if (debug_read_mem(0521))
2284      /* start a timer chain for the bit clock */
2285      disk_bitclk(0, 0);
2282//   if (debug_read_mem(0521))
2283   /* start a timer chain for the bit clock */
2284   disk_bitclk(0, 0);
22862285}
22872286
22882287/**
r26160r26161
23432342   m_dsk.ok_to_run_timer->adjust(attotime::from_nsec(15 * ALTO2_UCYCLE), 1);
23442343
23452344   m_dsk.ready_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(alto2_cpu_device::disk_ready_mf31a),this));
2346   m_dsk.ready_timer->adjust(attotime::never, 0);
2345   m_dsk.ready_timer->reset();
23472346
23482347   diablo_hd_device* dhd;
23492348   for (int unit = 0; unit < diablo_hd_device::DIABLO_UNIT_MAX; unit++) {
branches/alto2/src/emu/cpu/alto2/alto2.c
r26160r26161
4242alto2_cpu_device::alto2_cpu_device(const machine_config& mconfig, const char* tag, device_t* owner, UINT32 clock) :
4343   cpu_device(mconfig, ALTO2, "Xerox Alto-II", tag, owner, clock, "alto2", __FILE__),
4444#if   ALTO2_DEBUG
45   m_log_types(LOG_ALL),
45   m_log_types(LOG_0),
4646   m_log_level(9),
4747   m_log_newline(true),
4848#endif
branches/alto2/src/emu/cpu/alto2/alto2.h
r26160r26161
3333#define   ALTO2_BUSSRC   8         //!< 8 bus sources
3434#define   ALTO2_F1MAX      16         //!< 16 F1 functions
3535#define   ALTO2_F2MAX      16         //!< 16 F2 functions
36#define   ALTO2_UCYCLE   170         //!< time in nano seconds for a CPU micro cycle
36//! time in nano seconds for a CPU micro cycle
37#define   ALTO2_UCYCLE   static_cast<int>(clocks_to_attotime(1).as_double()/ATTOSECONDS_PER_NANOSECOND)
3738
3839#define   ALTO2_ETHER_FIFO_SIZE   16
3940

Previous 199869 Revisions Next

© 1997-2024 The MAME Team