Previous 199869 Revisions Next

r26228 Sunday 17th November, 2013 at 12:06:56 UTC by Jürgen Buchmüller
Check point. There's still something wrong with the polarity or timing of DIABLO drive vs. disk.
[/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
r26227r26228
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(6),
66   m_log_level(9),
6767#endif
6868   m_diablo31(true),
6969   m_unit(0),
r26227r26228
141141{
142142   if (m_sector_callback_cookie == cookie && m_sector_callback == callback)
143143      return;
144   LOG_DRIVE((0,"[DHD] %s cookie=%p callback=%p\n", __FUNCTION__, cookie, callback));
144   LOG_DRIVE((0,"[DHD%u] cookie=%p callback=%p\n", m_unit, cookie, callback));
145145   m_sector_callback_cookie = cookie;
146146   m_sector_callback = callback;
147147}
148148
149#define   DIABLO31_ROTATION_TIME attotime::from_msec(39.9999)      //!< DIABLO 31 rotation time is approx. 40ms
150#define   DIABLO31_SECTOR_TIME attotime::from_msec(39.9999/12)   //!< DIABLO 31 sector time
149#define   DIABLO31_ROTATION_TIME attotime::from_usec(40000)      //!< DIABLO 31 rotation time is approx. 40ms
150#define   DIABLO31_SECTOR_TIME attotime::from_usec(40000/12)      //!< DIABLO 31 sector time
151151/**
152152 * @brief DIABLO 31 bit clock is 3330kHz ~= 300ns per bit
153153 * ~= 133333 bits/track (?)
r26227r26228
155155 * ~= 347 words/sector
156156 */
157157#define   DIABLO31_BIT_TIME(bits) attotime::from_nsec(300*(bits))
158#define DIABLO31_SECTOR_BITS  11111
158159#define   DIABLO31_SECTOR_WORDS 347                        //!< DIABLO 31 possible sector words
159160#define   DIABLO31_SECTOR_MARK_PULSE_PRE DIABLO31_BIT_TIME(16)   //!< pulse width of sector mark before the next sector begins
160161#define   DIABLO31_SECTOR_MARK_PULSE_POST DIABLO31_BIT_TIME(16)   //!< pulse width of sector mark after the next sector began
161162
162#define   DIABLO44_ROTATION_TIME attotime::from_msec(25)         //!< DIABLO 44 rotation time is approx. 25ms
163#define   DIABLO44_SECTOR_TIME attotime::from_msec(25/12)         //!< DIABLO 44 sector time
163#define   DIABLO44_ROTATION_TIME attotime::from_usec(25000)      //!< DIABLO 44 rotation time is approx. 25ms
164#define   DIABLO44_SECTOR_TIME attotime::from_usec(25000/12)      //!< DIABLO 44 sector time
164165/**
165166 * @brief DIABLO 44 bit clock is 5000kHz ~= 200ns per bit
166167 * ~= 125184 bits/track (?)
r26227r26228
168169 * ~= 325 words/sector
169170 */
170171#define   DIABLO44_BIT_TIME(bits) attotime::from_nsec(200*(bits))
172#define DIABLO44_SECTOR_BITS  10432
171173#define   DIABLO44_SECTOR_WORDS   325                        //!< DIABLO 44 possible sector words
172174#define   DIABLO44_SECTOR_MARK_PULSE_PRE DIABLO44_BIT_TIME(16)   //!< pulse width of sector mark before the next sector begins
173175#define   DIABLO44_SECTOR_MARK_PULSE_POST DIABLO44_BIT_TIME(16)   //!< pulse width of sector mark after the next sector began
r26227r26228
292294{
293295   /* If there's no drive, just reset the page number */
294296   if (!m_image) {
295      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));
297      LOG_DRIVE((0,"[DHD%u]   C/H/S:%d/%d/%d => no image\n", m_unit, m_cylinder, m_head, m_sector));
296298      m_page = -1;
297299      return;
298300   }
299301   if (m_cylinder < 0 || m_cylinder >= DIABLO_CYLINDERS) {
300      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));
302      LOG_DRIVE((0,"[DHD%u]   C/H/S:%d/%d/%d => invalid cylinder\n", m_unit, m_cylinder, m_head, m_sector));
301303      m_page = -1;
302304      return;
303305   }
304306   if (m_head < 0 || m_head >= DIABLO_HEADS) {
305      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));
307      LOG_DRIVE((0,"[DHD%u]   C/H/S:%d/%d/%d => invalid head\n", m_unit, m_cylinder, m_head, m_sector));
306308      m_page = -1;
307309      return;
308310   }
309311   if (m_sector < 0 || m_sector >= DIABLO_SPT) {
310      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));
312      LOG_DRIVE((0,"[DHD%u]   C/H/S:%d/%d/%d => invalid sector\n", m_unit, m_cylinder, m_head, m_sector));
311313      m_page = -1;
312314      return;
313315   }
r26227r26228
316318
317319   // already have the sector image?
318320   if (m_cache[m_page]) {
319      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));
321      LOG_DRIVE((6,"[DHD%u]   C/H/S:%d/%d/%d => page:%d is cached\n", m_unit, m_cylinder, m_head, m_sector, m_page));
320322      return;
321323   }
322324
r26227r26228
324326   m_cache[m_page] = global_alloc_array(UINT8, sizeof(diablo_sector_t));
325327   /* and read the page from the hard_disk image */
326328   if (hard_disk_read(m_disk, m_page, m_cache[m_page])) {
327      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));
329      LOG_DRIVE((2,"[DHD%u]   C/H/S:%d/%d/%d => page:%d loaded\n", m_unit, m_cylinder, m_head, m_sector, m_page));
328330   } else {
329      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));
331      LOG_DRIVE((0,"[DHD%u]   C/H/S:%d/%d/%d => page:%d read failed\n", m_unit, m_cylinder, m_head, m_sector, m_page));
330332      global_free(m_cache[m_page]);
331333      m_cache[m_page] = 0;
332334   }
r26227r26228
445447
446448   /* allocate a sector buffer */
447449   if (!m_cache[m_page]) {
448      LOG_DRIVE((0,"[DHD]   %s: no image for #%d page #%d\n", __FUNCTION__, m_unit, m_page));
450      LOG_DRIVE((0,"[DHD%u]   no image for page #%d\n", m_unit, m_page));
449451      return NULL;
450452   }
451453   diablo_sector_t *s = reinterpret_cast<diablo_sector_t *>(m_cache[m_page]);
r26227r26228
492494   }
493495   m_bits[m_page] = bits;
494496
495   LOG_DRIVE((0,"[DHD]   %s: BITS #%d: %03d/%d/%02d #%-5d bits (@%03d.%02d)\n",
496      __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, dst, dst / 32, dst % 32));
497
497   LOG_DRIVE((0,"[DHD%u]   C/H/S:%03d/%d/%02d #%5d bits\n", m_unit, m_cylinder, m_head, m_sector, dst));
498#if   DIABLO_DEBUG
499   dump_record(s->pageno, 0, sizeof(s->pageno), "pageno", 0);
500   dump_record(s->header, 0, sizeof(s->header), "header", 0);
501   dump_record(s->label, 0, sizeof(s->label), "label", 0);
502   dump_record(s->data, 0, sizeof(s->data), "data", 1);
503#endif
498504   return bits;
499505}
500506
r26227r26228
576582      }
577583   }
578584   /* return if no sync found within size*32 clock and data bits */
579   LOG_DRIVE((0,"[DHD]   %s: no sync within %d words\n", __FUNCTION__, size));
585   LOG_DRIVE((0,"[DHD%u]   no sync within %d words\n", m_unit, size));
580586   return src;
581587}
582588
r26227r26228
611617      }
612618   }
613619   /* return if no sync found within size*32 clock and data bits */
614   LOG_DRIVE((0,"[DHD]   %s: no unsync within %d words\n", __FUNCTION__, size));
620   LOG_DRIVE((0,"[DHD%u]   no unsync within %d words\n", m_unit, size));
615621   return src;
616622}
617623
r26227r26228
684690   int cksum_header, cksum_label, cksum_data;
685691
686692   if (m_rdfirst >= 0) {
687      LOG_DRIVE((0, "[DHD]   %s: RD #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
688         __FUNCTION__, m_unit, m_cylinder, m_head, m_sector,
689         m_rdfirst, m_rdfirst / 32, m_rdfirst % 32,
690         m_rdlast, m_rdlast / 32, m_rdlast % 32));
693      LOG_DRIVE((0, "[DHD%u]   RD CHS:%03d/%d/%02d bit#%-5d ... bit#%-5d\n",
694         m_cylinder, m_head, m_sector, m_rdfirst, m_rdlast));
691695   }
692696   m_rdfirst = -1;
693697   m_rdlast = -1;
r26227r26228
707711   }
708712
709713   if (m_wrfirst >= 0) {
710      LOG_DRIVE((0, "[DHD]   %s: WR #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
711         __FUNCTION__, m_unit, m_cylinder, m_head, m_sector,
712         m_wrfirst, m_wrfirst / 32, m_wrfirst % 32,
713         m_wrlast, m_wrlast / 32, m_wrlast % 32));
714      LOG_DRIVE((0, "[DHD%u]   WR C/H/S:%03d/%d/%02d bit#%-5d ... bit#%-5d\n",
715               m_unit, m_cylinder, m_head, m_sector, m_wrfirst, m_wrlast));
714716   }
715717   m_wrfirst = -1;
716718   m_wrlast = -1;
717719
718720   if (m_page < 0 || m_page >= DIABLO_PAGES) {
719      LOG_DRIVE((0,"[DHD]   %s: no sector for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
721      LOG_DRIVE((0,"[DHD%u]   page not set\n", m_unit));
720722      return;
721723   }
722724
723725   if (!m_cache[m_page]) {
724      LOG_DRIVE((0,"[DHD]   %s: no image for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
726      LOG_DRIVE((0,"[DHD%u]   no image\n", m_unit));
725727      return;
726728   }
727729
728730   /* no bits to write? */
729731   if (!m_bits[m_page]) {
730      LOG_DRIVE((0,"[DHD]   %s: no bits for #%d: %d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
732      LOG_DRIVE((0,"[DHD%u]   no bits\n", m_unit));
731733      return;
732734   }
733735   UINT32 *bits = m_bits[m_page];
r26227r26228
743745   src = squeeze_unsync(bits, src, 40);
744746   /* sync on header preamble */
745747   src = squeeze_sync(bits, src, 40);
746   LOG_DRIVE((0,"[DHD]   %s: header sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
748   LOG_DRIVE((0,"[DHD%u]   header sync bit #%5d\n", m_unit, src));
747749   src = squeeze_record(bits, src, s->header, sizeof(s->header));
748750   src = squeeze_cksum(bits, src, &cksum_header);
749751#if   DIABLO_DEBUG
r26227r26228
754756   src = squeeze_unsync(bits, src, 40);
755757   /* sync on label preamble */
756758   src = squeeze_sync(bits, src, 40);
757   LOG_DRIVE((0,"[DHD]   %s: label sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
759   LOG_DRIVE((0,"[DHD%u]   label sync bit #%5d\n", m_unit, src));
758760   src = squeeze_record(bits, src, s->label, sizeof(s->label));
759761   src = squeeze_cksum(bits, src, &cksum_label);
760762#if   DIABLO_DEBUG
r26227r26228
765767   src = squeeze_unsync(bits, src, 40);
766768   /* sync on data preamble */
767769   src = squeeze_sync(bits, src, 40);
768   LOG_DRIVE((0,"[DHD]   %s: data   sync bit #%d (@%03d.%02d)\n", __FUNCTION__, src, src / 32, src % 32));
770   LOG_DRIVE((0,"[DHD%u]   data sync bit #%5d\n", m_unit, src));
769771   src = squeeze_record(bits, src, s->data, sizeof(s->data));
770772   src = squeeze_cksum(bits, src, &cksum_data);
771773#if   DIABLO_DEBUG
r26227r26228
779781
780782   if (cksum_header || cksum_label || cksum_data) {
781783#if   DIABLO_DEBUG
782      LOG_DRIVE((0,"[DHD]   %s: cksum check - header:%06o label:%06o data:%06o\n", __FUNCTION__, cksum_header, cksum_label, cksum_data));
784      LOG_DRIVE((0,"[DHD%u]   cksum check - header:%06o label:%06o data:%06o\n", m_unit, cksum_header, cksum_label, cksum_data));
783785#endif
784786   }
785787   global_free(m_bits[m_page]);
786788   m_bits[m_page] = 0;
787789
788790   if (!hard_disk_write(m_disk, m_page, m_cache[m_page])) {
789      LOG_DRIVE((0,"[DHD]   %s: write failed for #%d page #%d\n", __FUNCTION__, m_unit, m_page));
791      LOG_DRIVE((0,"[DHD%u]   write failed for page #%d\n", m_unit, m_page));
790792   }
791793}
792794
793795/**
794 * @brief return number of bitclk edges for a sector
796 * @brief return number of bit clocks for a sector (clock and data)
795797 * @return number of bitclks for a sector
796798 */
797799int diablo_hd_device::bits_per_sector() const
798800{
799   return m_diablo31 ? DIABLO31_SECTOR_WORDS * 32 : DIABLO44_SECTOR_WORDS * 32;
801    return m_diablo31 ? DIABLO31_SECTOR_BITS : DIABLO44_SECTOR_BITS;
800802}
801803
802804/**
r26227r26228
805807 */
806808const char* diablo_hd_device::description() const
807809{
808   return m_description;
810    return m_description;
809811}
810812
811813/**
r26227r26228
814816 */
815817int diablo_hd_device::unit() const
816818{
817   return m_unit;
819    return m_unit;
818820}
819821
820822/**
r26227r26228
823825 */
824826attotime diablo_hd_device::rotation_time() const
825827{
826   return m_rotation_time;
828    return m_rotation_time;
827829}
828830
829831/**
r26227r26228
832834 */
833835attotime diablo_hd_device::sector_time() const
834836{
835   return m_sector_time;
837    return m_sector_time;
836838}
837839
838840/**
r26227r26228
841843 */
842844attotime diablo_hd_device::bit_time() const
843845{
844   return m_bit_time;
846    return m_bit_time;
845847}
846848
847849/**
r26227r26228
850852 */
851853int diablo_hd_device::get_seek_read_write_0() const
852854{
853   return m_s_r_w_0;
855    return m_s_r_w_0;
854856}
855857
856858/**
r26227r26228
859861 */
860862int diablo_hd_device::get_ready_0() const
861863{
862   return m_ready_0;
864    return m_ready_0;
863865}
864866
865867/**
r26227r26228
887889 */
888890int diablo_hd_device::get_addx_acknowledge_0() const
889891{
890   return m_addx_acknowledge_0;
892    return m_addx_acknowledge_0;
891893}
892894
893895/**
r26227r26228
896898 */
897899int diablo_hd_device::get_log_addx_interlock_0() const
898900{
899   return m_log_addx_interlock_0;
901    return m_log_addx_interlock_0;
900902}
901903
902904/**
r26227r26228
905907 */
906908int diablo_hd_device::get_seek_incomplete_0() const
907909{
908   return m_seek_incomplete_0;
910    return m_seek_incomplete_0;
909911}
910912
911913/**
r26227r26228
919921 */
920922int diablo_hd_device::get_cylinder() const
921923{
922   return m_cylinder;
924    return m_cylinder;
923925}
924926
925927/**
r26227r26228
933935 */
934936int diablo_hd_device::get_head() const
935937{
936   return m_head;
938    return m_head;
937939}
938940
939941/**
r26227r26228
951953 */
952954int diablo_hd_device::get_sector() const
953955{
954   return m_sector;
956    return m_sector;
955957}
956958
957959/**
r26227r26228
965967 */
966968int diablo_hd_device::get_page() const
967969{
968   return m_page;
970    return m_page;
969971}
970972
971973/**
r26227r26228
980982   /* this drive is selected */
981983   if ((head & DIABLO_HEAD_MASK) != m_head) {
982984      m_head = head & DIABLO_HEAD_MASK;
983      LOG_DRIVE((0,"[DHD]   %s: unit:%d head:%d\n", __FUNCTION__, unit, head));
985      LOG_DRIVE((0,"[DHD%u]   select unit:%d head:%d\n", m_unit, unit, head));
984986   }
985987
986988   if (m_image) {
r26227r26228
988990      m_s_r_w_0 = 0;               // and can take seek/read/write commands
989991      m_addx_acknowledge_0 = 0;      // assert address acknowledge (?)
990992      m_log_addx_interlock_0 = 1;      // deassert log address interlock (?)
991      LOG_DRIVE((1,"[DHD]   %s: UNIT select %d ready\n", __FUNCTION__, unit));
993      LOG_DRIVE((1,"[DHD%u]   select unit:%d ready\n", m_unit, unit));
992994   } else {
993995      m_ready_0 = 1;               // it is not ready (?)
994996      m_s_r_w_0 = 1;               // can't take seek/read/write commands (?)
995997      m_addx_acknowledge_0 = 0;      // assert address acknowledge (?)
996998      m_log_addx_interlock_0 = 1;      // deassert log address interlock (?)
997      LOG_DRIVE((1,"[DHD]   %s: UNIT select %d not ready (no image)\n", __FUNCTION__, unit));
999      LOG_DRIVE((1,"[DHD%u]   select unit:%d not ready (no image)\n", m_unit, unit));
9981000   }
9991001   read_sector();
10001002}
r26227r26228
10131015{
10141016   int seekto = restore ? 0 : cylinder;
10151017   if (strobe) {
1016      LOG_DRIVE((1,"[DHD]   %s: STROBE end of interlock\n", __FUNCTION__, seekto));
1018      LOG_DRIVE((1,"[DHD%u]   STROBE end of interlock\n", m_unit));
10171019      // deassert the log address interlock
10181020      m_log_addx_interlock_0 = 1;
10191021      return;
r26227r26228
10231025   m_log_addx_interlock_0 = 0;
10241026
10251027   if (seekto == m_cylinder) {
1026      LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d acknowledge\n", __FUNCTION__, seekto));
1028      LOG_DRIVE((1,"[DHD%u]   STROBE to cylinder %d acknowledge\n", m_unit, seekto));
10271029      m_addx_acknowledge_0 = 0;   // address acknowledge, if cylinder is reached
10281030      m_seek_incomplete_0 = 1;   // reset seek incomplete
10291031      return;
r26227r26228
10381040         m_log_addx_interlock_0 = 1;   // deassert the log address interlock signal
10391041         m_seek_incomplete_0 = 1;   // deassert seek incomplete signal
10401042         m_addx_acknowledge_0 = 0;   // assert address acknowledge signal
1041         LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d incomplete\n", __FUNCTION__, seekto));
1043         LOG_DRIVE((1,"[DHD%u]   STROBE to cylinder %d incomplete\n", m_unit, seekto));
10421044         return;
10431045      }
10441046   }
r26227r26228
10501052         m_log_addx_interlock_0 = 1;   // deassert the log address interlock signal
10511053         m_seek_incomplete_0 = 1;   // deassert seek incomplete signal
10521054         m_addx_acknowledge_0 = 0;   // assert address acknowledge signal
1053         LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d incomplete\n", __FUNCTION__, seekto));
1055         LOG_DRIVE((1,"[DHD%u]   STROBE to cylinder %d incomplete\n", m_unit, seekto));
10541056         return;
10551057      }
10561058   }
1057   LOG_DRIVE((1,"[DHD]   %s: STROBE to cylinder %d (now %d) - interlock\n", __FUNCTION__, seekto, m_cylinder));
1059   LOG_DRIVE((1,"[DHD%u]   STROBE to cylinder %d (now %d) - interlock\n", m_unit, seekto, m_cylinder));
10581060
10591061   m_addx_acknowledge_0 = 1;   // deassert address acknowledge signal
10601062   m_seek_incomplete_0 = 1;   // deassert seek incomplete signal
r26227r26228
10671069 */
10681070void diablo_hd_device::set_egate(int gate)
10691071{
1070   m_egate_0 = gate & 1;
1072    m_egate_0 = gate & 1;
10711073}
10721074
10731075/**
r26227r26228
10761078 */
10771079void diablo_hd_device::set_wrgate(int gate)
10781080{
1079   m_wrgate_0 = gate & 1;
1081    m_wrgate_0 = gate & 1;
10801082}
10811083
10821084/**
r26227r26228
10851087 */
10861088void diablo_hd_device::set_rdgate(int gate)
10871089{
1088   m_rdgate_0 = gate & 1;
1090    m_rdgate_0 = gate & 1;
10891091}
10901092
10911093/**
r26227r26228
11081110void diablo_hd_device::wr_data(int index, int wrdata)
11091111{
11101112   if (m_wrgate_0) {
1111      LOG_DRIVE((0,"[DHD]   %s: unit #%d wrgate not asserted\n", __FUNCTION__, m_unit));
1113      LOG_DRIVE((0,"[DHD%u]   wrgate not asserted\n", m_unit));
11121114      return;   // write gate is not asserted (active 0)
11131115   }
11141116
11151117   if (index < 0 || index >= bits_per_sector()) {
1116      LOG_DRIVE((0,"[DHD]   %s: unit #%d index out of range (%d)\n", __FUNCTION__, m_unit, index));
1118      LOG_DRIVE((0,"[DHD%u]   index out of range (%d)\n", m_unit, index));
11171119      return;   // don't write before or beyond the sector
11181120   }
11191121
11201122   if (-1 == m_page) {
1121      LOG_DRIVE((0,"[DHD]   %s: unit #%d invalid page\n", __FUNCTION__, m_unit));
1123      LOG_DRIVE((0,"[DHD%u]   invalid page\n", m_unit));
11221124      return;   // invalid page
11231125   }
11241126
r26227r26228
11261128   if (-1 == m_wrfirst)
11271129      m_wrfirst = index;
11281130
1129   LOG_DRIVE((7,"[DHD]   %s: unit #%d %d/%d/%d bit #%d bit:%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector, index, wrdata));
1131   LOG_DRIVE((7,"[DHD%u]   C/H/S:%d/%d/%d index #%d bit:%d\n", m_unit, m_cylinder, m_head, m_sector, index, wrdata));
11301132
11311133   if (index < GUARD_ZONE_BITS) {
11321134      /* don't write in the guard zone (?) */
r26227r26228
11501152   int bit = 0;
11511153
11521154   if (m_rdgate_0) {
1153      LOG_DRIVE((8,"[DHD]   %s: unit #%d rdgate not asserted\n", __FUNCTION__, m_unit));
1154      return 0;   // read gate is not asserted (active 0)
1155      LOG_DRIVE((8,"[DHD%u]   rdgate not asserted\n", m_unit));
1156      return 1;   // read gate is not asserted (active 0)
11551157   }
11561158
11571159   if (index < 0 || index >= bits_per_sector()) {
1158      LOG_DRIVE((0,"[DHD]   %s: unit #%d index out of range (%d)\n", __FUNCTION__, m_unit, index));
1160      LOG_DRIVE((0,"[DHD%u]   index out of range (%d)\n", m_unit, index));
11591161      return 1;   // don't read before or beyond the sector
11601162   }
11611163
11621164   if (0 == m_sector_mark_0) {
1163      LOG_DRIVE((0,"[DHD]   %s: unit #%d read while sector mark is asserted\n", __FUNCTION__, m_unit));
1165      LOG_DRIVE((0,"[DHD%u]   read while sector mark is asserted\n", m_unit));
11641166      return 1;   // no data while sector mark is asserted
11651167   }
11661168
11671169   if (-1 == m_page) {
1168      LOG_DRIVE((0,"[DHD]   %s: unit #%d invalid page\n", __FUNCTION__, m_unit));
1170      LOG_DRIVE((0,"[DHD%u]   invalid page\n", m_unit));
11691171      return 1;   // invalid page
11701172   }
11711173
r26227r26228
11741176      m_rdfirst = index;
11751177
11761178   RDBIT(bits,index,bit);
1177   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));
1179   LOG_DRIVE((7,"[DHD%u]   C/H/S:%d/%d/%d index #%d bit:%d\n", m_unit, m_cylinder, m_head, m_sector, index, bit));
11781180   m_rdlast = index;
11791181   return bit;
11801182}
r26227r26228
11931195   int clk = 0;
11941196
11951197   if (index < 0 || index >= bits_per_sector()) {
1196      LOG_DRIVE((0,"[DHD]   %s: unit #%d index out of range (%d)\n", __FUNCTION__, m_unit, index));
1198      LOG_DRIVE((0,"[DHD%u]   index out of range (%d)\n", m_unit, index));
11971199      return 1;   // don't read before or beyond the sector
11981200   }
11991201
12001202   if (0 == m_sector_mark_0) {
1201      LOG_DRIVE((0,"[DHD]   %s: unit #%d read while sector mark is asserted\n", __FUNCTION__, m_unit));
1203      LOG_DRIVE((0,"[DHD%u]   read while sector mark is asserted\n", m_unit));
12021204      return 1;   // no clock while sector mark is low (?)
12031205   }
12041206
12051207   if (-1 == m_page) {
1206      LOG_DRIVE((0,"[DHD]   %s: unit #%d invalid page\n", __FUNCTION__, m_unit));
1208      LOG_DRIVE((0,"[DHD%u]   invalid page\n", m_unit));
12071209      return 1;   // invalid page
12081210   }
12091211
r26227r26228
12191221   } else {
12201222      clk = 0;
12211223   }
1222   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));
1224   LOG_DRIVE((7,"[DHD%u]   C/H/S:%d/%d/%d index #%d clk:%d\n", m_unit, m_cylinder, m_head, m_sector, index, clk));
12231225   m_rdlast = index;
12241226   return clk ^ 1;
12251227}
r26227r26228
12301232 */
12311233void diablo_hd_device::sector_mark_1()
12321234{
1233   LOG_DRIVE((9,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
1234   /* set sector mark to 1 */
1235   m_sector_mark_0 = 1;
1235   LOG_DRIVE((9,"[DHD%u]   C/H/S:%d/%d/%d sector_mark_0=1\n", m_unit, m_cylinder, m_head, m_sector));
1236   m_sector_mark_0 = 1;   // deassert sector mark (set to 1)
12361237}
12371238
12381239/**
r26227r26228
12451246 */
12461247void diablo_hd_device::sector_mark_0()
12471248{
1248   LOG_DRIVE((9,"[DHD]   %s: unit #%d C/H/S:%d/%d/%d\n", __FUNCTION__, m_unit, m_cylinder, m_head, m_sector));
1249   LOG_DRIVE((9,"[DHD%u]   C/H/S:%d/%d/%d sector_mark_0=0\n", m_unit, m_cylinder, m_head, m_sector));
12491250
1250   // squeeze previous sector bits, if it was written to
1251   squeeze_sector();
1252
1253   m_sector_mark_0 = 0;
1254
1251   squeeze_sector();      // squeeze previous sector bits, if it was written to
1252   m_sector_mark_0 = 0;   // assert sector mark (set to 0)
12551253   // reset read and write bit locations
12561254   m_rdfirst = -1;
12571255   m_rdlast = -1;
r26227r26228
12681266   m_image = static_cast<diablo_image_device *>(subdevice("drive"));
12691267
12701268   m_packs = 1;      // FIXME: get from configuration?
1269   m_unit = strstr(m_image->tag(), "diablo0") ? 0 : 1;
12711270
12721271   m_cache = global_alloc_array(UINT8*, DIABLO_PAGES);
12731272   memset(m_cache, 0, sizeof(UINT8*) * DIABLO_PAGES);
r26227r26228
12971296      m_sector_mark_1_time = DIABLO44_SECTOR_MARK_PULSE_PRE;
12981297      m_bit_time = DIABLO44_BIT_TIME(1);
12991298   }
1300   LOG_DRIVE((0,"[DHD]   %s: rotation time       : %.0fns\n", __FUNCTION__, 1e9 * m_rotation_time.as_double()));
1301   LOG_DRIVE((0,"[DHD]   %s: sector time         : %.0fns\n", __FUNCTION__, 1e9 * m_sector_time.as_double()));
1302   LOG_DRIVE((0,"[DHD]   %s: sector mark 0 time  : %.0fns\n", __FUNCTION__, 1e9 * m_sector_mark_0_time.as_double()));
1303   LOG_DRIVE((0,"[DHD]   %s: sector mark 1 time  : %.0fns\n", __FUNCTION__, 1e9 * m_sector_mark_1_time.as_double()));
1304   LOG_DRIVE((0,"[DHD]   %s: bit time            : %.0fns\n", __FUNCTION__, 1e9 * m_bit_time.as_double()));
1299   LOG_DRIVE((0,"[DHD%u]   rotation time       : %.0fns\n", m_unit, m_rotation_time.as_double() * ATTOSECONDS_PER_NANOSECOND));
1300   LOG_DRIVE((0,"[DHD%u]   sector time         : %.0fns\n", m_unit, m_sector_time.as_double() * ATTOSECONDS_PER_NANOSECOND));
1301   LOG_DRIVE((0,"[DHD%u]   sector mark 0 time  : %.0fns\n", m_unit, m_sector_mark_0_time.as_double() * ATTOSECONDS_PER_NANOSECOND));
1302   LOG_DRIVE((0,"[DHD%u]   sector mark 1 time  : %.0fns\n", m_unit, m_sector_mark_1_time.as_double() * ATTOSECONDS_PER_NANOSECOND));
1303   LOG_DRIVE((0,"[DHD%u]   bit time            : %.0fns\n", m_unit, m_bit_time.as_double() * ATTOSECONDS_PER_NANOSECOND));
13051304
13061305   m_s_r_w_0 = 1;               // deassert seek/read/write ready
13071306   m_ready_0 = 1;               // deassert drive ready
r26227r26228
13131312   // reset the disk drive's address
13141313   m_cylinder = 0;
13151314   m_head = 0;
1316   m_sector = 0;
1317   m_page = 0;
1315   m_sector = 10;
1316   m_page = 10;
13181317
13191318   // disable the erase, write and read gates
13201319   m_egate_0 = 1;
r26227r26228
13381337 * @brief timer callback that is called thrice per sector in the rotation
13391338 *
13401339 * The timer is called three times at the events:
1341 * 0: sector mark goes inactive
1342 * 1: sector mark goes active
1340 * 0: sector mark goes active
1341 * 1: sector mark goes inactive
13431342 * 2: in the middle of the active phase
13441343 *
13451344 * @param id timer id
r26227r26228
13471346 */
13481347void diablo_hd_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
13491348{
1350   LOG_DRIVE((6,"[DHD]   %s: id=%d param=%d ptr=%p @%lldns\n", __FUNCTION__, id, param, ptr, (long long int)(timer.elapsed().as_double() * ATTOSECONDS_PER_NANOSECOND)));
1349   LOG_DRIVE((6,"[DHD%u]   TIMER id=%d param=%d ptr=%p @%.0fns\n", m_unit, id, param, ptr, timer.elapsed().as_double() * ATTOSECONDS_PER_NANOSECOND));
13511350
13521351   switch (param) {
13531352   case 0:
1353      // assert sector mark
1354      sector_mark_0();
1355      // next sector timer event is in the middle between sector_mark going 0 and back to 1
13541356      timer.adjust(m_sector_mark_0_time, 1);
1355      /* assert sector mark */
1356      sector_mark_0();
13571357      break;
13581358   case 1:
1359      /* next sector starting soon now */
1360      timer.adjust(m_sector_mark_1_time, 2);
13611359      /* call the sector_callback, if any */
13621360      if (m_sector_callback)
13631361         (void)(*m_sector_callback)(m_sector_callback_cookie, m_unit);
1362      // next sector timer event is deassert of sector_mark_0 (set to 1)
1363      timer.adjust(m_sector_mark_1_time, 2);
13641364      break;
13651365   case 2:
1366      // deassert sector mark
1367      sector_mark_1();
1368      // next sector timer event is sector_mark_0 for next sector
13661369      timer.adjust(m_sector_time - m_sector_mark_0_time, 0);
1367      /* deassert sector mark */
1368      sector_mark_1();
13691370      break;
13701371   }
13711372}
branches/alto2/src/emu/cpu/alto2/a2disk.c
r26227r26228
10461046   int i;
10471047   UINT8 s0, s1;
10481048
1049   LOG((LOG_DISK,8,"   >>> KWD timing bitclk:%d datin:%d block:%d SECT[4]:%d\n", bitclk, datin, block, dhd->get_sector_mark_0()));
1049   LOG((LOG_DISK,9,"   *** KWD timing bitclk:%d datin:%d block:%d\n", bitclk, datin, block));
10501050   if (0 == m_dsk.seclate) {
10511051      // if SECLATE is 0, WDDONE' never goes low (counter's clear has precedence).
10521052      if (m_dsk.bitcount || m_dsk.carry) {
r26227r26228
14141414    */
14151415   DEBUG_NAME("\t\t21a KSEC  ");
14161416   s0 = m_dsk.ff_21a;
1417   s1 = dhd->get_sector_mark_0() ? JKFF_0 : JKFF_CLK;
1417   s1 = dhd->get_sector_mark_0() ? JKFF_CLK : JKFF_0;
14181418   if (!(m_dsk.ff_22b & JKFF_Q))
14191419      s1 |= JKFF_J;
14201420   s1 |= JKFF_K;
r26227r26228
14401440         // log the reason why gates are deasserted
14411441         LOG((LOG_DISK,6,"   deassert gates because of"));
14421442         if (m_task_wakeup & (1 << task_ksec)) {
1443            LOG((LOG_DISK,6," wake KSEC"));
1443            LOG((LOG_DISK,6," KSECWAKE"));
14441444         }
14451445         if (GET_KCOM_XFEROFF(m_dsk.kcom)) {
14461446            LOG((LOG_DISK,6," XFEROFF"));
r26227r26228
14481448         if (m_dsk.kfer) {
14491449            LOG((LOG_DISK,6," KFER"));
14501450         }
1451         LOG((LOG_DISK,6,"\n"));
14511452      }
14521453#endif
14531454      // sector task is active OR xferoff is set OR fatal error
r26227r26228
14661467               if (m_dsk.wrgate) {
14671468                  LOG((LOG_DISK,6," WRGATE"));
14681469               }
1470               LOG((LOG_DISK,6,"\n"));
14691471            }
14701472#endif
14711473            // assert erase and write gates
r26227r26228
14751477      } else {
14761478#if   ALTO2_DEBUG
14771479         if (1 == m_dsk.rdgate) {
1478            LOG((LOG_DISK,6,"   assert RDGATE"));
1480            LOG((LOG_DISK,6,"   assert RDGATE\n"));
14791481         }
14801482#endif
14811483         // assert read gate
r26227r26228
14861488   m_dsk.ff_21a_old = m_dsk.ff_21a;
14871489   m_dsk.bitclk = bitclk;
14881490   m_dsk.datin = datin;
1489   LOG((LOG_DISK,8,"   <<< KWD timing\n"));
14901491}
14911492
14921493
r26227r26228
16201621 */
16211622void alto2_cpu_device::disk_block(int task)
16221623{
1623   kwd_timing(m_dsk.bitclk, m_dsk.datin, task);
1624    kwd_timing(m_dsk.bitclk, m_dsk.datin, task);
16241625}
16251626
16261627/**
r26227r26228
21492150void alto2_cpu_device::f2_swrnrdy_1()
21502151{
21512152   diablo_hd_device* dhd = m_drive[m_dsk.drive];
2152   UINT16 r = dhd ? dhd->get_seek_read_write_0() : 1;
2153//   UINT16 r = dhd->get_seek_read_write_0();
2154   UINT16 r = dhd->get_ready_0();
21532155   UINT16 init = (m_task == task_kwd && m_dsk.wdinit0) ? 037 : 0;
21542156
21552157   LOG((LOG_DISK,1,"   SWRNRDY; %sbranch (%#o|%#o|%#o)\n", (r | init) ? "" : "no ", m_next2, r, init));
r26227r26228
23102312#else
23112313   // TODO: verify current sector == requested sector and only then run the bitclk?
23122314   // HACK: no command, no bit clock
2313   if (debug_read_mem(0521))
2315//   if (debug_read_mem(0521))
23142316   {
23152317      // Make the CPU execution loop call disk_bitclk
23162318      m_bitclk_time = 0;
r26227r26228
23742376   m_dsk.seclate_timer->reset();
23752377
23762378   m_dsk.ok_to_run_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(alto2_cpu_device::disk_ok_to_run),this));
2377   m_dsk.ok_to_run_timer->adjust(attotime::from_nsec(15 * ALTO2_UCYCLE), 1);
2379   m_dsk.ok_to_run_timer->adjust(attotime::from_nsec(35 * ALTO2_UCYCLE), 1);
23782380
23792381   m_dsk.ready_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(alto2_cpu_device::disk_ready_mf31a),this));
23802382   m_dsk.ready_timer->reset();
branches/alto2/src/emu/cpu/alto2/alto2.c
r26227r26228
7676   AM_RANGE(0177776,                    0177776)                           AM_READWRITE( noop_r, noop_w )          // { Digital-Analog Converter, Joystick }
7777   AM_RANGE(0177777,                    0177777)                           AM_READWRITE( noop_r, noop_w )          // { Digital-Analog Converter, Joystick }
7878
79   AM_RANGE(0200000,                    0377777)                           AM_READWRITE( ioram_r, ioram_w )
79//   AM_RANGE(0200000,                    0377777)                           AM_READWRITE( ioram_r, ioram_w )
8080ADDRESS_MAP_END
8181
8282//-------------------------------------------------
r26227r26228
8686alto2_cpu_device::alto2_cpu_device(const machine_config& mconfig, const char* tag, device_t* owner, UINT32 clock) :
8787   cpu_device(mconfig, ALTO2, "Xerox Alto-II", tag, owner, clock, "alto2", __FILE__),
8888#if   ALTO2_DEBUG
89   m_log_types(LOG_DISK|LOG_KSEC|LOG_KWD|LOG_KBD),
90   m_log_level(6),
89   m_log_types(LOG_DISK|LOG_KSEC|LOG_KWD),
90   m_log_level(8),
9191   m_log_newline(true),
9292#endif
9393   m_ucode_config("ucode", ENDIANNESS_BIG, 32, 12, -2 ),
9494   m_const_config("const", ENDIANNESS_BIG, 16,  8, -1 ),
95   m_iomem_config("iomem", ENDIANNESS_BIG, 16, 17, -1 ),
96   m_ucode(0),
97   m_const(0),
98   m_iomem(0),
95   m_iomem_config("iomem", ENDIANNESS_BIG, 16, 16, -1 ),
9996   m_ucode_crom(0),
10097   m_const_data(0),
10198   m_icount(0),
r26227r26228
211208      // last line had a \n - print type name
212209      for (int i = 0; i < sizeof(type_name)/sizeof(type_name[0]); i++)
213210         if (type & (1 << i))
214            logerror("%-7s ", type_name[i]);
211            logerror("%-7s %11lld ", type_name[i], cycle());
215212   }
216213   va_list ap;
217214   va_start(ap, format);
r26227r26228
945942// FIXME
946943void alto2_cpu_device::device_start()
947944{
948   m_ucode = &space(AS_0);
949   m_const = &space(AS_1);
945   // get a pointer to the IO address space
950946   m_iomem = &space(AS_2);
951947
952948   // decode micro code PROMs to CROM
r26227r26228
961957   // decode constant PROMs to const data
962958   m_const_data = prom_load(pl_const, memregion("const_proms")->base(), 1, 4);
963959
964   for (UINT32 offs = 0; offs < 256; offs++) {
965      UINT16 cdata = m_const->read_word(m_const->address_to_byte(offs));
966      printf("%04o: %06o\n", offs, cdata);
967   }
968
969960   m_disp_a38 = prom_load(&pl_displ_a38, memregion("displ_a38")->base());
970961   m_disp_a63 = prom_load(&pl_displ_a63, memregion("displ_a63")->base());
971962   m_disp_a66 = prom_load(&pl_displ_a66, memregion("displ_a66")->base());
branches/alto2/src/emu/cpu/alto2/alto2.h
r26227r26228
3535#define   ALTO2_BUSSRC   8         //!< 8 bus sources
3636#define   ALTO2_F1MAX      16         //!< 16 F1 functions
3737#define   ALTO2_F2MAX      16         //!< 16 F2 functions
38//! time in nano seconds for a CPU micro cycle
39#define   ALTO2_UCYCLE   271         //!< 29.4912MHz/8 -> 3.6864MHz ~= 271ns/clock
38#define   ALTO2_UCYCLE   271         //!< time in nano seconds for a CPU micro cycle: 29.4912MHz/8 -> 3.6864MHz ~= 271ns/clock
4039
4140#define   ALTO2_ETHER_FIFO_SIZE   16
4241
r26227r26228
305304   address_space_config m_const_config;
306305   address_space_config m_iomem_config;
307306
308   address_space *m_ucode;
309   address_space *m_const;
310   address_space *m_iomem;
307   address_space* m_iomem;
311308
312309   UINT8* m_ucode_crom;
313310   UINT8* m_ucode_cram;
r26227r26228
339336
340337   int m_icount;
341338
342   static const UINT8 m_ether_id = 0121;
339   static const UINT8 m_ether_id = 0377;
343340
344341   typedef void (alto2_cpu_device::*a2func)();
345342   typedef void (alto2_cpu_device::*a2cb)(int unit);

Previous 199869 Revisions Next

© 1997-2024 The MAME Team