| /* | |
| * BESM-6 magnetic disk device | |
| * | |
| * Copyright (c) 2009, Serge Vakulenko | |
| * Copyright (c) 2009, Leonid Broukhis | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * The above copyright notice and this permission notice shall be included in | |
| * all copies or substantial portions of the Software. | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * SERGE VAKULENKO OR LEONID BROUKHIS BE LIABLE FOR ANY CLAIM, DAMAGES | |
| * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE | |
| * OR OTHER DEALINGS IN THE SOFTWARE. | |
| * Except as contained in this notice, the name of Leonid Broukhis or | |
| * Serge Vakulenko shall not be used in advertising or otherwise to promote | |
| * the sale, use or other dealings in this Software without prior written | |
| * authorization from Leonid Broukhis and Serge Vakulenko. | |
| */ | |
| #include "besm6_defs.h" | |
| #include <ctype.h> | |
| /* | |
| * Управляющее слово обмена с магнитным диском. | |
| */ | |
| #define DISK_BLOCK 0740000000 /* номер блока памяти - 27-24 рр */ | |
| #define DISK_READ_SYSDATA 004000000 /* считывание только служебных слов */ | |
| #define DISK_PAGE_MODE 001000000 /* обмен целой страницей */ | |
| #define DISK_READ 000400000 /* чтение с диска в память */ | |
| #define DISK_PAGE 000370000 /* номер страницы памяти */ | |
| #define DISK_HALFPAGE 000004000 /* выбор половины листа */ | |
| #define DISK_UNIT 000001600 /* номер устройства */ | |
| #define DISK_HALFZONE 000000001 /* выбор половины зоны */ | |
| /* | |
| * "Хороший" статус чтения/записи. | |
| * Вычислено по текстам ОС Дубна. | |
| * Диспак доволен. | |
| */ | |
| #define STATUS_GOOD 014000400 | |
| /* | |
| * Total size of a disk in blocks, including hidden blocks | |
| */ | |
| #define DISK_TOTBLK 01767 | |
| /* | |
| * Параметры обмена с внешним устройством. | |
| */ | |
| typedef struct { | |
| int op; /* Условное слово обмена */ | |
| int dev; /* Номер устройства, 0..7 */ | |
| int zone; /* Номер зоны на диске */ | |
| int track; /* Выбор половины зоны на диске */ | |
| int memory; /* Начальный адрес памяти */ | |
| int format; /* Флаг разметки */ | |
| int status; /* Регистр состояния */ | |
| t_value mask_grp; /* Маска готовности для ГРП */ | |
| int mask_fail; /* Маска ошибки обмена */ | |
| t_value *sysdata; /* Буфер системных данных */ | |
| } KMD; | |
| static KMD controller [2]; /* Две стойки КМД */ | |
| int disk_fail; /* Маска ошибок по направлениям */ | |
| t_stat disk_event (UNIT *u); | |
| /* | |
| * DISK data structures | |
| * | |
| * disk_dev DISK device descriptor | |
| * disk_unit DISK unit descriptor | |
| * disk_reg DISK register list | |
| */ | |
| UNIT disk_unit [16] = { | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| { UDATA (disk_event, UNIT_FIX+UNIT_ATTABLE+UNIT_ROABLE, DISK_SIZE) }, | |
| }; | |
| REG disk_reg[] = { | |
| { ORDATA ( "КУС_0", controller[0].op, 24) }, | |
| { ORDATA ( "УСТР_0", controller[0].dev, 3) }, | |
| { ORDATA ( "ЗОНА_0", controller[0].zone, 10) }, | |
| { ORDATA ( "ДОРОЖКА_0", controller[0].track, 2) }, | |
| { ORDATA ( "МОЗУ_0", controller[0].memory, 20) }, | |
| { ORDATA ( "РС_0", controller[0].status, 24) }, | |
| { ORDATA ( "КУС_1", controller[1].op, 24) }, | |
| { ORDATA ( "УСТР_1", controller[1].dev, 3) }, | |
| { ORDATA ( "ЗОНА_1", controller[1].zone, 10) }, | |
| { ORDATA ( "ДОРОЖКА_1", controller[1].track, 2) }, | |
| { ORDATA ( "МОЗУ_1", controller[1].memory, 20) }, | |
| { ORDATA ( "РС_1", controller[1].status, 24) }, | |
| { ORDATA ( "ОШ", disk_fail, 6) }, | |
| { 0 } | |
| }; | |
| MTAB disk_mod[] = { | |
| { 0 } | |
| }; | |
| t_stat disk_reset (DEVICE *dptr); | |
| t_stat disk_attach (UNIT *uptr, CONST char *cptr); | |
| t_stat disk_detach (UNIT *uptr); | |
| DEVICE disk_dev = { | |
| "DISK", disk_unit, disk_reg, disk_mod, | |
| 16, 8, 21, 1, 8, 50, | |
| NULL, NULL, &disk_reset, NULL, &disk_attach, &disk_detach, | |
| NULL, DEV_DISABLE | DEV_DEBUG | |
| }; | |
| /* | |
| * Определение контроллера по устройству. | |
| */ | |
| static KMD *unit_to_ctlr (UNIT *u) | |
| { | |
| if (u < &disk_unit[8]) | |
| return &controller[0]; | |
| else | |
| return &controller[1]; | |
| } | |
| /* | |
| * Reset routine | |
| */ | |
| t_stat disk_reset (DEVICE *dptr) | |
| { | |
| int i; | |
| memset (&controller, 0, sizeof (controller)); | |
| controller[0].sysdata = &memory [030]; | |
| controller[1].sysdata = &memory [040]; | |
| controller[0].mask_grp = GRP_CHAN3_FREE; | |
| controller[1].mask_grp = GRP_CHAN4_FREE; | |
| controller[0].mask_fail = 020; | |
| controller[1].mask_fail = 010; | |
| for (i=0; i<16; ++i) | |
| sim_cancel (&disk_unit[i]); | |
| return SCPE_OK; | |
| } | |
| t_stat disk_attach (UNIT *u, CONST char *cptr) | |
| { | |
| t_stat s; | |
| int32 saved_switches = sim_switches; | |
| sim_switches |= SWMASK ('E'); | |
| while (1) { | |
| s = attach_unit (u, cptr); | |
| if ((s == SCPE_OK) && (sim_switches & SWMASK ('N'))) { | |
| t_value control[4]; /* block (zone) number, key, userid, checksum */ | |
| int diskno, blkno, word; | |
| const char *pos; | |
| /* Using the rightmost sequence of digits within the filename | |
| * as a volume number, e.g. "/var/tmp/besm6/2052.bin" -> 2052 | |
| */ | |
| pos = cptr + strlen(cptr); | |
| while (pos > cptr && !isdigit(*--pos)); | |
| while (pos > cptr && isdigit(*pos)) --pos; | |
| if (!isdigit(*pos)) ++pos; | |
| diskno = atoi(pos); | |
| if (diskno < 2048 || diskno > 4095) { | |
| if (diskno == 0) | |
| sim_printf ("%s: filename must contain volume number 2048..4095\n", sim_uname(u)); | |
| else | |
| sim_printf ("%s: disk volume %d from filename %s invalid (must be 2048..4095)\n", | |
| sim_uname (u), diskno, cptr); | |
| /* unlink (cptr); ??? */ | |
| return SCPE_ARG; | |
| } | |
| if (!sim_quiet && !(sim_switches & SWMASK ('Q'))) | |
| sim_printf ("%s: formatting disk volume %d\n", sim_uname (u), diskno); | |
| control[1] = SET_PARITY(0, PARITY_NUMBER); | |
| control[2] = SET_PARITY(0, PARITY_NUMBER); | |
| control[3] = SET_PARITY(0, PARITY_NUMBER); | |
| control[1] |= 01370707LL << 24; /* Magic mark */ | |
| control[1] |= diskno << 12; | |
| for (blkno = 0; blkno < DISK_TOTBLK; ++blkno) { | |
| control[0] = SET_PARITY((t_value)(2*blkno) << 36, PARITY_NUMBER); | |
| sim_fwrite(control, sizeof(t_value), 4, u->fileref); | |
| control[0] = SET_PARITY((t_value)(2*blkno+1) << 36, PARITY_NUMBER); | |
| sim_fwrite(control, sizeof(t_value), 4, u->fileref); | |
| for (word = 0; word < 02000; ++word) { | |
| sim_fwrite(control+2, sizeof(t_value), 1, u->fileref); | |
| } | |
| } | |
| return SCPE_OK; | |
| } | |
| if (s == SCPE_OK || | |
| (saved_switches & SWMASK ('E')) || | |
| (sim_switches & SWMASK('N'))) | |
| return s; | |
| sim_switches |= SWMASK ('N'); | |
| } | |
| return SCPE_OK; | |
| } | |
| t_stat disk_detach (UNIT *u) | |
| { | |
| /* TODO: сброс бита ГРП готовности направления при отключении последнего диска. */ | |
| return detach_unit (u); | |
| } | |
| t_value spread (t_value val) | |
| { | |
| int i, j; | |
| t_value res = 0; | |
| for (i = 0; i < 5; i++) | |
| for (j = 0; j < 9; j++) | |
| if (val & (1LL<<(i+j*5))) | |
| res |= 1LL << (i*9+j); | |
| return res & BITS48; | |
| } | |
| /* | |
| * Отладочная печать массива данных обмена. | |
| */ | |
| static void log_data (t_value *data, int nwords) | |
| { | |
| int i; | |
| t_value val; | |
| for (i=0; i<nwords; ++i) { | |
| val = data[i]; | |
| fprintf (sim_log, " %04o-%04o-%04o-%04o", | |
| (int) (val >> 36) & 07777, | |
| (int) (val >> 24) & 07777, | |
| (int) (val >> 12) & 07777, | |
| (int) val & 07777); | |
| if ((i & 3) == 3) | |
| fprintf (sim_log, "\n"); | |
| } | |
| if ((i & 3) != 0) | |
| fprintf (sim_log, "\n"); | |
| } | |
| /* | |
| * Сложение с переносом вправо. | |
| */ | |
| static unsigned sum_with_right_carry (unsigned a, unsigned b) | |
| { | |
| unsigned c; | |
| while (b) { | |
| c = a & b; | |
| a ^= b; | |
| b = c >> 1; | |
| } | |
| return a; | |
| } | |
| /* | |
| * Запись на диск. | |
| */ | |
| void disk_write (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: запись МД %o зона %04o память %05o-%05o", | |
| c->dev, c->zone, c->memory, c->memory + 1023); | |
| if (fseek (u->fileref, ZONE_SIZE * c->zone * 8, SEEK_SET) == 0) { | |
| sim_fwrite (c->sysdata, 8, 8, u->fileref); | |
| sim_fwrite (&memory [c->memory], 8, 1024, u->fileref); | |
| } | |
| if (ferror (u->fileref)) | |
| longjmp (cpu_halt, SCPE_IOERR); | |
| } | |
| void disk_write_track (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: запись МД %o полузона %04o.%d память %05o-%05o", | |
| c->dev, c->zone, c->track, c->memory, c->memory + 511); | |
| if (fseek (u->fileref, (ZONE_SIZE*c->zone + 4*c->track) * 8, | |
| SEEK_SET) == 0) { | |
| sim_fwrite (c->sysdata + 4*c->track, 8, 4, u->fileref); | |
| if (fseek (u->fileref, (8 + ZONE_SIZE*c->zone + 512*c->track) * 8, | |
| SEEK_SET) == 0) { | |
| sim_fwrite (&memory [c->memory], 8, 512, u->fileref); | |
| } | |
| } | |
| if (ferror (u->fileref)) | |
| longjmp (cpu_halt, SCPE_IOERR); | |
| } | |
| /* | |
| * Форматирование дорожки. | |
| */ | |
| void disk_format (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| t_value fmtbuf[5], *ptr; | |
| int i; | |
| /* По сути, эмулятору ничего делать не надо. */ | |
| if (! disk_dev.dctrl) | |
| return; | |
| /* Находим начало записываемого заголовка. */ | |
| ptr = &memory [c->memory]; | |
| while ((*ptr & BITS48) == 0) | |
| ptr++; | |
| /* Декодируем из гребенки в нормальный вид. */ | |
| for (i = 0; i < 5; i++) | |
| fmtbuf[i] = spread (ptr[i]); | |
| /* При первой попытке разметки адресный маркер начинается в старшем 5-разрядном слоге, | |
| * пропускаем первый слог. */ | |
| for (i=0; i<4; i++) | |
| fmtbuf[i] = ((fmtbuf[i] & BITS48) << 5) | | |
| ((fmtbuf[i+1] >> 40) & BITS(5)); | |
| /* Печатаем идентификатор, адрес и контрольную сумму адреса. */ | |
| besm6_debug ("::: формат МД %o полузона %04o.%d память %05o и-а-кса %010o %010o", | |
| c->dev, c->zone, c->track, c->memory, | |
| (int) (fmtbuf[0] >> 8 & BITS(30)), | |
| (int) (fmtbuf[2] >> 14 & BITS(30))); | |
| /* log_data (fmtbuf, 4); */ | |
| } | |
| /* | |
| * Чтение с диска. | |
| */ | |
| void disk_read (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| if (disk_dev.dctrl) | |
| besm6_debug ((c->op & DISK_READ_SYSDATA) ? | |
| "::: чтение МД %o зона %04o служебные слова" : | |
| "::: чтение МД %o зона %04o память %05o-%05o", | |
| c->dev, c->zone, c->memory, c->memory + 1023); | |
| if (fseek (u->fileref, ZONE_SIZE * c->zone * 8, SEEK_SET) != 0 || | |
| sim_fread (c->sysdata, 8, 8, u->fileref) != 8) { | |
| /* Чтение неинициализированного диска */ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| if (! (c->op & DISK_READ_SYSDATA) && | |
| sim_fread (&memory [c->memory], 8, 1024, u->fileref) != 1024) { | |
| /* Чтение неинициализированного диска */ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| if (ferror (u->fileref)) | |
| longjmp (cpu_halt, SCPE_IOERR); | |
| } | |
| t_value collect (t_value val) | |
| { | |
| int i, j; | |
| t_value res = 0; | |
| for (i = 0; i < 5; i++) | |
| for (j = 0; j < 9; j++) | |
| if (val & (1LL<<(i*9+j))) | |
| res |= 1LL << (i+j*5); | |
| return res & BITS48; | |
| } | |
| void disk_read_track (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| if (disk_dev.dctrl) | |
| besm6_debug ((c->op & DISK_READ_SYSDATA) ? | |
| "::: чтение МД %o полузона %04o.%d служебные слова" : | |
| "::: чтение МД %o полузона %04o.%d память %05o-%05o", | |
| c->dev, c->zone, c->track, c->memory, c->memory + 511); | |
| if (fseek (u->fileref, (ZONE_SIZE*c->zone + 4*c->track) * 8, SEEK_SET) != 0 || | |
| sim_fread (c->sysdata + 4*c->track, 8, 4, u->fileref) != 4) { | |
| /* Чтение неинициализированного диска */ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| if (! (c->op & DISK_READ_SYSDATA)) { | |
| if (fseek (u->fileref, (8 + ZONE_SIZE*c->zone + 512*c->track) * 8, | |
| SEEK_SET) != 0 || | |
| sim_fread (&memory [c->memory], 8, 512, u->fileref) != 512) { | |
| /* Чтение неинициализированного диска */ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| } | |
| if (ferror (u->fileref)) | |
| longjmp (cpu_halt, SCPE_IOERR); | |
| } | |
| /* | |
| * Чтение заголовка дорожки. | |
| */ | |
| void disk_read_header (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| t_value *sysdata = c->sysdata + 4*c->track; | |
| int iaksa, i, cyl, head; | |
| /* Адрес: номер цилиндра и головки. */ | |
| head = (c->zone << 1) + c->track; | |
| cyl = head / 10; | |
| head %= 10; | |
| iaksa = (cyl << 20) | (head << 16); | |
| /* Идентификатор дорожки замены. */ | |
| if (c->zone >= 01750) | |
| iaksa |= BBIT(30); | |
| /* Контрольная сумма адреса с переносом вправо. */ | |
| iaksa |= BITS(12) & ~sum_with_right_carry (iaksa >> 12, iaksa >> 24); | |
| /* Амиакса, 42 нуля, амиакса, много единиц. */ | |
| sysdata[0] = 07404000000000000LL | (t_value) iaksa << 8; | |
| sysdata[1] = 03740LL; | |
| sysdata[2] = 00400000000037777LL | (t_value) iaksa << 14; | |
| sysdata[3] = BITS48; | |
| if (disk_dev.dctrl) | |
| log_data (sysdata, 4); | |
| /* Кодируем гребенку. */ | |
| for (i=0; i<4; i++) | |
| sysdata[i] = SET_PARITY (collect (sysdata[i]), PARITY_NUMBER); | |
| } | |
| /* | |
| * Задание адреса памяти и длины массива для последующего обращения к диску. | |
| * Номера дисковода и дорожки будут выданы позже, командой 033 0023(0024). | |
| */ | |
| void disk_io (int ctlr, uint32 cmd) | |
| { | |
| KMD *c = &controller [ctlr]; | |
| c->op = cmd; | |
| c->format = 0; | |
| if (c->op & DISK_PAGE_MODE) { | |
| /* Обмен страницей */ | |
| c->memory = (cmd & DISK_PAGE) >> 2 | (cmd & DISK_BLOCK) >> 8; | |
| } else { | |
| /* Обмен половиной страницы (дорожкой) */ | |
| c->memory = (cmd & (DISK_PAGE | DISK_HALFPAGE)) >> 2 | (cmd & DISK_BLOCK) >> 8; | |
| } | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: задание на %s %08o", ctlr + '3', | |
| (c->op & DISK_READ) ? "чтение" : "запись", cmd); | |
| #endif | |
| disk_fail &= ~c->mask_fail; | |
| /* Гасим главный регистр прерываний. */ | |
| GRP &= ~c->mask_grp; | |
| } | |
| /* | |
| * Управление диском: команда 00 033 0023(0024). | |
| */ | |
| void disk_ctl (int ctlr, uint32 cmd) | |
| { | |
| KMD *c = &controller [ctlr]; | |
| UNIT *u = &disk_unit [c->dev]; | |
| if (cmd & BBIT(12)) { | |
| /* Выдача в КМД адреса дорожки. | |
| * Здесь же выполняем обмен с диском. | |
| * Номер дисковода к этому моменту уже известен. */ | |
| if ((disk_dev.flags & DEV_DIS) || ! (u->flags & UNIT_ATT)) { | |
| /* Device not attached. */ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| c->zone = (cmd >> 1) & BITS(10); | |
| c->track = cmd & 1; | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: выдача адреса дорожки %04o.%d", | |
| ctlr + '3', c->zone, c->track); | |
| #endif | |
| disk_fail &= ~c->mask_fail; | |
| if (c->op & DISK_READ) { | |
| if (c->op & DISK_PAGE_MODE) | |
| disk_read (u); | |
| else | |
| disk_read_track (u); | |
| } else { | |
| if (u->flags & UNIT_RO) { | |
| /* Read only. */ | |
| /*longjmp (cpu_halt, SCPE_RO);*/ | |
| disk_fail |= c->mask_fail; | |
| return; | |
| } | |
| if (c->format) | |
| disk_format (u); | |
| else if (c->op & DISK_PAGE_MODE) | |
| disk_write (u); | |
| else | |
| disk_write_track (u); | |
| } | |
| /* Ждём события от устройства. */ | |
| sim_activate (u, 20*USEC); /* Ускорим для отладки. */ | |
| } else if (cmd & BBIT(11)) { | |
| /* Выбора номера устройства и занесение в регистр маски КМД. | |
| * Бит 8 - устройство 0, бит 7 - устройство 1, ... бит 1 - устройство 7. | |
| * Также установлен бит 9 - что он означает? */ | |
| if (cmd & BBIT(8)) c->dev = 7; | |
| else if (cmd & BBIT(7)) c->dev = 6; | |
| else if (cmd & BBIT(6)) c->dev = 5; | |
| else if (cmd & BBIT(5)) c->dev = 4; | |
| else if (cmd & BBIT(4)) c->dev = 3; | |
| else if (cmd & BBIT(3)) c->dev = 2; | |
| else if (cmd & BBIT(2)) c->dev = 1; | |
| else if (cmd & BBIT(1)) c->dev = 0; | |
| else { | |
| /* Неверная маска выбора устройства. */ | |
| c->dev = -1; | |
| return; | |
| } | |
| c->dev += ctlr << 3; | |
| u = &disk_unit[c->dev]; | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: выбор устройства %d", | |
| ctlr + '3', c->dev); | |
| #endif | |
| if ((disk_dev.flags & DEV_DIS) || ! (u->flags & UNIT_ATT)) { | |
| /* Device not attached. */ | |
| disk_fail |= c->mask_fail; | |
| GRP &= ~c->mask_grp; | |
| } | |
| GRP |= c->mask_grp; | |
| } else if (cmd & BBIT(9)) { | |
| /* Проверка прерывания от КМД? */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: проверка готовности", | |
| ctlr + '3'); | |
| #endif | |
| GRP |= c->mask_grp; | |
| } else { | |
| /* Команда, выдаваемая в КМД. */ | |
| switch (cmd & 077) { | |
| case 000: /* диспак выдаёт эту команду один раз в начале загрузки */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: недокументированная команда 00", | |
| ctlr + '3'); | |
| #endif | |
| break; | |
| case 001: /* сброс на 0 цилиндр */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: сброс на 0 цилиндр", | |
| ctlr + '3'); | |
| #endif | |
| break; | |
| case 002: /* подвод */ | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: подвод", ctlr + '3'); | |
| break; | |
| case 003: /* чтение (НСМД-МОЗУ) */ | |
| case 043: /* резервной дорожки */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: чтение", ctlr + '3'); | |
| #endif | |
| break; | |
| case 004: /* запись (МОЗУ-НСМД) */ | |
| case 044: /* резервной дорожки */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: запись", ctlr + '3'); | |
| #endif | |
| break; | |
| case 005: /* разметка */ | |
| c->format = 1; | |
| break; | |
| case 006: /* сравнение кодов (МОЗУ-НСМД) */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: сравнение кодов", ctlr + '3'); | |
| #endif | |
| break; | |
| case 007: /* чтение заголовка */ | |
| case 047: /* резервной дорожки */ | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: чтение %s заголовка", ctlr + '3', | |
| cmd & 040 ? "резервного" : ""); | |
| disk_fail &= ~c->mask_fail; | |
| disk_read_header (u); | |
| /* Ждём события от устройства. */ | |
| sim_activate (u, 20*USEC); /* Ускорим для отладки. */ | |
| break; | |
| case 010: /* гашение PC */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: гашение регистра состояния", | |
| ctlr + '3'); | |
| #endif | |
| c->status = 0; | |
| break; | |
| case 011: /* опрос 1÷12 разрядов PC */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: опрос младших разрядов состояния", | |
| ctlr + '3'); | |
| #endif | |
| if (disk_unit[c->dev].flags & UNIT_ATT) | |
| c->status = STATUS_GOOD & BITS(12); | |
| else | |
| c->status = 0; | |
| break; | |
| case 031: /* опрос 13÷24 разрядов РС */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: опрос старших разрядов состояния", | |
| ctlr + '3'); | |
| #endif | |
| if (disk_unit[c->dev].flags & UNIT_ATT) | |
| c->status = (STATUS_GOOD >> 12) & BITS(12); | |
| else | |
| c->status = 0; | |
| break; | |
| case 050: /* освобождение НМД */ | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: освобождение накопителя", | |
| ctlr + '3'); | |
| #endif | |
| break; | |
| default: | |
| besm6_debug ("::: КМД %c: неизвестная команда %02o", | |
| ctlr + '3', cmd & 077); | |
| GRP |= c->mask_grp; /* чтобы не зависало */ | |
| break; | |
| } | |
| } | |
| } | |
| /* | |
| * Запрос состояния контроллера. | |
| */ | |
| int disk_state (int ctlr) | |
| { | |
| KMD *c = &controller [ctlr]; | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД %c: опрос состояния = %04o", | |
| ctlr + '3', c->status); | |
| #endif | |
| return c->status; | |
| } | |
| /* | |
| * Событие: закончен обмен с МД. | |
| * Устанавливаем флаг прерывания. | |
| */ | |
| t_stat disk_event (UNIT *u) | |
| { | |
| KMD *c = unit_to_ctlr (u); | |
| GRP |= c->mask_grp; | |
| return SCPE_OK; | |
| } | |
| /* | |
| * Опрос ошибок обмена командой 033 4035. | |
| */ | |
| int disk_errors () | |
| { | |
| #if 0 | |
| if (disk_dev.dctrl) | |
| besm6_debug ("::: КМД: опрос шкалы ошибок = %04o", disk_fail); | |
| #endif | |
| return disk_fail; | |
| } |