![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rtl8019as.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm|
Return to rtl8019as.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2023 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: //
8: // Nereid イーサネット (RTL8019AS)
9: //
10:
11: // ローカル側のアドレス空間は以下の配置のようだ。
12: //
13: // 0000-3fff: PROM (32 バイトでミラー)
14: // 4000-7fff: バッファ RAM (16KB)
15: // 8000-bfff: バスか何かの都合で多少再現性のある不定データが読めるようだ
16: // c000-ffff: バッファ RAM (16KB) のミラーのようだ
17:
18: // PROM 領域(32バイト)をバイトで読み出すと以下のように読める。
19: // 0000: 00 00 50 50 C2 C2 10 10 YY YY ZZ ZZ FF FF FF FF
20: // 0010: FF FF FF FF FF FF FF FF FF FF FF FF 57 57 57 57
21: //
22: // 同領域をワードで読み出すと以下のように読める。
23: // 0000: 00FF 50FF C2FF 10FF YYFF ZZFF FFFF FFFF
24: // 0010: FFFF FFFF FFFF FFFF FFFF FFFF 57FF 57FF
25: //
26: // MAC アドレスは 00:50:C2:10:YY:ZZ。
27: // $001c あたりは 'B'($42) か 'W'($57) で、バイトかワードかを示すらしい。
28:
29: // メモ。電源オン時のレジスタ値ダンプ:
30: // (1回目)
31: // Page0: 21 00 FF 9F 13 00 00 EF FF FF 50 70 16 00 00 00
32: // Page1: 61 00 05 02 02 10 64 F7 01 B0 91 20 01 20 60 02
33: // Page2: A1 80 00 FF 00 FF FF FF FF FF FF FF D1 E0 C6 80
34: // Page3: E1 30 00 00 90 00 10 FF 00 FE FF FD FF FE FF FF
35: // (2回目)
36: // Page0: 21 00 FF BF 13 00 00 EF FF FF 50 70 16 00 00 00
37: // Page1: 61 00 01 00 02 00 44 F7 01 B0 91 20 00 20 20 02
38: // Page2: A1 80 00 FF 00 FF FF FF FF FF FF FF D1 E0 86 80
39: // Page3: E1 30 00 00 90 00 10 FF 00 FE FF FD FF FE FF FF
40:
41: #include "rtl8019as.h"
42: #include "interrupt.h"
43: #include "scheduler.h"
44:
45: // コンストラクタ
46: RTL8019ASDevice::RTL8019ASDevice(int n, int vector_)
47: : inherited(OBJ_ETHERNET(n))
48: {
49: SetName(string_format("RTL8019AS#%d", n));
50: ClearAlias();
51: AddAlias(string_format("RTL8019AS%d", n));
52: AddAlias(string_format("Eth%d", n));
53:
54: intr_vector = vector_;
55:
56: tx_event.func = ToEventCallback(&RTL8019ASDevice::TXEvent);
57: tx_event.Regist(string_format("RTL8019AS%d TX", n));
58: rx_event.func = ToEventCallback(&RTL8019ASDevice::RXEvent);
59: rx_event.Regist(string_format("RTL8019AS%d RX", n));
60:
61: txled_event.func = ToEventCallback(&RTL8019ASDevice::TXLedEvent);
62: txled_event.Regist(string_format("RTL8019AS%d TX LED", n));
63: rxled_event.func = ToEventCallback(&RTL8019ASDevice::RXLedEvent);
64: rxled_event.Regist(string_format("RTL8019AS%d RX LED", n));
65:
66: monitor.func = ToMonitorCallback(&RTL8019ASDevice::MonitorUpdate);
67: monitor.SetSize(71, 19);
68: monitor.Regist(ID_MONITOR_RTL8019AS(n));
69: }
70:
71: // デストラクタ
72: RTL8019ASDevice::~RTL8019ASDevice()
73: {
74: }
75:
76: // 初期化
77: bool
78: RTL8019ASDevice::Init()
79: {
80: if (inherited::Init() == false) {
81: return false;
82: }
83:
84: int n = GetId() - OBJ_ETHERNET0;
85:
86: // MAC アドレスを取得
87: macaddr_t macaddr;
88: if (inherited::GetConfigMacAddr(n, &macaddr, false) == false) {
89: // エラーメッセージ表示済み
90: return false;
91: }
92: // PROM 領域 (実質16バイト) を作成
93: memset(&prom[0], 0xff, prom.size());
94: uint8 *d = &prom[0];
95: for (auto m : macaddr) {
96: *d++ = m;
97: }
98: prom[0xe] = 'W';
99: prom[0xf] = 'W';
100:
101: interrupt = GetInterruptDevice();
102:
103: // ホストからの受信コールバックを登録
104: scheduler->ConnectMessage(MessageID::HOSTNET_RX(n), this,
105: ToMessageCallback(&RTL8019ASDevice::HostRxCallback));
106:
107: return true;
108: }
109:
110: // リセット
111: void
112: RTL8019ASDevice::ResetHard(bool poweron)
113: {
114: if (poweron) {
115: // 電源オン時の不定値は適当。ハードリセットの影響を受けない。
116: // いずれにしても極力ゼロじゃない値にしておく。
117: local_addr = 0xff00;
118: boundary_addr = 0xcf00;
119: current_page_addr = 0xfc00;
120: remote_addr = 0xffff;
121:
122: // TSR/RSR は初回送信/受信時まで不定 (DP83901A.pdf)
123: tsr = 0xcc;
124: rsr = 0xcc;
125:
126: // PSTART は電源オンでだいたいこれが読める?
127: // ハードリセットの影響を受けない。
128: pstart_addr = 0x8000;
129:
130: // RCR は電源オン時だいたい $d1 な気がする
131: monitor_mode = false;
132: promisc_mode = true;
133: accept_mcast = false;
134: accept_bcast = false;
135: accept_short = false;
136: accept_error = true;
137:
138: // TCR は電源オン時だいたい $e0 な気がする
139: tcr = 0x00;
140:
141: // DCR は電源オン時 $86 になることが多い気がする
142: dcr = RTL8019::DCR_BOS;
143:
144: // XXX カウンタがリセットでどうなるかは未調査
145: for (auto& c : error_counter) {
146: c = 0;
147: }
148: }
149:
150: // 処理中は全部破棄
151: scheduler->StopEvent(tx_event);
152: scheduler->StopEvent(rx_event);
153: tx_in_progress = false;
154: rx_packet.Clear();
155:
156: // LED は電源オンで点灯。リセットでも点灯に戻りそうな気はする。
157: tx_led = true;
158: rx_led = true;
159: scheduler->StopEvent(txled_event);
160: scheduler->StopEvent(rxled_event);
161:
162: // ハードリセットで、TPSR, RCR は変化しない。
163:
164: // CR は初期化される。
165: pagesel = 0;
166: dmamode = DMAMode::Complete;
167:
168: // PSTOP は 0 になるように見える。
169: pstop_addr = 0x0000;
170:
171: // TCR.LB は 0 (Normal Operation) になる。それ以外は変化しない。
172: tcr &= ~RTL8019::TCR_LB_MASK;
173:
174: // DCR は LAS=1 になる。それ以外は変化しない。
175: dcr |= RTL8019::DCR_LAS;
176:
177: // ISR は、電源オン後にクリアしろと書いてあるのでおそらく不定。
178: // 実際 $ef が読めがち。
179: intr_stat = 0xef;
180: intr_mask = 0x00;
181: ChangeState(State::Stop);
182:
183: // Page3 の RTL8019AS 部分はだいたいリセットされそう?
184: config_write_enable = false;
185: verid = 0;
186: irq_enable = true;
187: brom_force_disable = false;
188:
189: // XXX 初期値は?
190: mediatype = RTL8019::MediaType_10BaseT_Auto;
191:
192: ChangeInterrupt();
193: }
194:
195: // リセットポートによるソフトリセット
196: void
197: RTL8019ASDevice::Reset()
198: {
199: // リセットといっても実質ほぼ Stop じゃないかと思う。
200: // 実際ざっと試した限りレジスタの値は変化しなかった。
201: ChangeState(State::Stop);
202: }
203:
204: /*static*/ inline uint32
205: RTL8019ASDevice::Decoder(uint32 addr)
206: {
207: return addr & 0x3f;
208: }
209:
210: uint64
211: RTL8019ASDevice::Read8(uint32 addr)
212: {
213: uint32 offset = Decoder(addr);
214: uint32 data;
215:
216: if (offset < 0x10 * 2) {
217: if (offset % 2 == 0) {
218: uint32 rn = pagesel + offset / 2;
219: data = ReadReg(rn);
220: } else {
221: // 奇数番地はバスエラーではなく $ff が読める
222: putlog(4, "Reading $%06x", addr);
223: data = 0xff;
224: }
225: } else if (offset < 0x18 * 2) {
226: data = ReadDMA8(offset & 1);
227: } else {
228: putlog(1, "Reset");
229: Reset();
230: data = 0xff;
231: }
232:
233: return data;
234: }
235:
236: uint64
237: RTL8019ASDevice::Read16(uint32 addr)
238: {
239: uint32 offset = Decoder(addr);
240: uint32 data;
241:
242: if (offset < 0x10 * 2) {
243: uint32 rn = pagesel + offset / 2;
244: data = ReadReg(rn) << 8;
245: data |= 0xff;
246: } else if (offset < 0x18 * 2) {
247: data = ReadDMA16();
248: } else {
249: putlog(1, "Reset");
250: Reset();
251: data = 0xffff;
252: }
253:
254: return data;
255: }
256:
257: uint64
258: RTL8019ASDevice::Write8(uint32 addr, uint32 data)
259: {
260: uint32 offset = Decoder(addr);
261:
262: if (offset < 0x10 * 2) {
263: if (offset % 2 == 0) {
264: uint32 rn = pagesel + offset / 2;
265: return WriteReg(rn, data);
266: } else {
267: // 奇数番地はバスエラーにならない
268: putlog(4, "Writing $%06x <- $%02x", addr, data);
269: return 0;
270: }
271: } else if (offset < 0x18 * 2) {
272: WriteDMA8(data);
273: } else {
274: putlog(1, "Reset");
275: Reset();
276: }
277:
278: return 0;
279: }
280:
281: uint64
282: RTL8019ASDevice::Write16(uint32 addr, uint32 data)
283: {
284: uint32 offset = Decoder(addr);
285:
286: if (offset < 0x10 * 2) {
287: uint32 rn = pagesel + offset / 2;
288: return WriteReg(rn, data >> 8);
289: } else if (offset < 0x18 * 2) {
290: WriteDMA16(data);
291: } else {
292: putlog(2, "Reset");
293: Reset();
294: }
295:
296: return 0;
297: }
298:
299: uint64
300: RTL8019ASDevice::Peek8(uint32 addr)
301: {
302: uint32 offset = Decoder(addr);
303:
304: if (offset < 0x10 * 2) {
305: if (offset % 2 == 0) {
306: uint32 n = pagesel + offset / 2;
307: return PeekReg(n);
308: } else {
309: return 0xff;
310: }
311: } else if (offset < 0x18 * 2) {
312: return PeekDMA(offset & 1);
313: } else {
314: // XXX ?
315: return 0xff;
316: }
317: }
318:
319: void
320: RTL8019ASDevice::MonitorUpdate(Monitor *, TextScreen& screen)
321: {
322: uint32 val;
323: const int x = 6;
324: const int x2 = 59;
325: int y;
326:
327: screen.Clear();
328: y = 0;
329:
330: // 0 1 2 3 4 5
331: // 012345678901234567890123456789012345678901234567890123456789
332: // CFG0 $xx 12345 12345 12345 12345 12345 12345 12345 12345
333:
334: val = PeekCR();
335: screen.Puts(0, y, "CR:");
336: screen.Print(x, y, "$%02x", val);
337: static const char * const cr_bits[] = {
338: "", "", "", "", "", "TXP", "STA", "STP"
339: };
340: MonitorReg(screen, x + 4, y, val, cr_bits);
341: screen.Print(x + 4, y, "PageSel=%x", val >> 6);
342: uint rd = (val >> 3) & 7;
343: screen.Print(x + 16, y, "RD=%x(%s)", rd, GetDMAName(rd));
344: y++;
345:
346: val = PeekISR();
347: screen.Puts(0, y, "ISR:");
348: screen.Print(x, y, "$%02x", val);
349: static const char * const isr_bits[] = {
350: "RST", "RDC", "CNT", "OVW", "TXE", "RXE", "PTX", "PRX"
351: };
352: MonitorReg(screen, x + 4, y, val, isr_bits);
353: y++;
354:
355: val = PeekIMR();
356: screen.Puts(0, y, "IMR:");
357: screen.Print(x, y, "$%02x", val);
358: static const char * const imr_bits[] = {
359: "-1", "RDCE", "CNTE", "OVWE", "TXEE", "RXEE", "PTXE", "PRXE"
360: };
361: MonitorReg(screen, x + 4, y, val, imr_bits);
362: y++;
363:
364: val = PeekDCR();
365: screen.Puts(0, y, "DCR:");
366: screen.Print(x, y, "$%02x", val);
367: static const char * const dcr_bits[] = {
368: "-1", "FT1", "FT0", "ARM", "LS", "LAS", "(BOS)", "WTS"
369: };
370: MonitorReg(screen, x + 4, y, val, dcr_bits);
371: y++;
372:
373: val = PeekTCR();
374: screen.Puts(0, y, "TCR:");
375: screen.Print(x, y, "$%02x", val);
376: static const char * const tcr_bits[] = {
377: "-1", "-1", "-1", "OFST", "ATD", "LB1", "LB0", "CRC"
378: };
379: MonitorReg(screen, x + 4, y, val, tcr_bits);
380: y++;
381:
382: val = PeekTSR();
383: screen.Puts(0, y, "TSR:");
384: screen.Print(x, y, "$%02x", val);
385: static const char * const tsr_bits[] = {
386: "OWC", "CDH", "-0", "CRS", "ABT", "COL", "-1", "PTX"
387: };
388: MonitorReg(screen, x + 4, y, val, tsr_bits);
389: y++;
390:
391: val = PeekRCR();
392: screen.Puts(0, y, "RCR:");
393: screen.Print(x, y, "$%02x", val);
394: static const char * const rcr_bits[] = {
395: "-1", "-1", "MON", "PRO", "AM", "AB", "AR", "SEP"
396: };
397: MonitorReg(screen, x + 4, y, val, rcr_bits);
398: y++;
399:
400: val = PeekRSR();
401: screen.Puts(0, y, "RSR:");
402: screen.Print(x, y, "$%02x", val);
403: static const char * const rsr_bits[] = {
404: "DFR", "DIS", "PHY", "MPA", "-0", "FAE", "CRC", "PRX"
405: };
406: MonitorReg(screen, x + 4, y, val, rsr_bits);
407: y++;
408:
409: screen.Puts(0, y, "PAR:");
410: screen.Print(x, y, "%02x", par[0]);
411: for (int i = 1; i < 6; i++) {
412: screen.Print(x - 1 + i * 3, y, ":%02x", par[i]);
413: }
414:
415: screen.Puts(x + 21, y, "MAR:");
416: screen.Print(x + 26, y, "%02x", mar[0]);
417: for (int i = 1; i < 8; i++) {
418: screen.Print(x + 25 + i * 3, y, ":%02x", mar[i]);
419: }
420: y++;
421:
422: y++;
423:
424: val = Peek9346CR();
425: screen.Puts(0, y, "9346:");
426: screen.Print(x, y, "$%02x", val);
427: static const char * const cr9346_bits[] = {
428: "EEM1", "EEM0", "-1", "-1", "EECS", "EESK", "EEDI", "EEDO"
429: };
430: MonitorReg(screen, x + 4, y, val, cr9346_bits);
431: uint eem = val >> 6;
432: y++;
433:
434: val = PeekCONFIG0();
435: screen.Puts(0, y, "CFG0:");
436: screen.Print(x, y, "$%02x", val);
437: static const char * const config0_bits[] = {
438: "VID1", "VID0", "AUI", "PNPJP", "JP", "BNC", "-0", "-0"
439: };
440: MonitorReg(screen, x + 4, y, val, config0_bits);
441: y++;
442:
443: val = PeekCONFIG1();
444: screen.Puts(0, y, "CFG1:");
445: screen.Print(x, y, "$%02x", val);
446: static const char * const config1_bits[] = {
447: "IRQEN", "IRQS2", "IRQS1", "IRQS0", "IOS3", "IOS2", "IOS1", "IOS0"
448: };
449: MonitorReg(screen, x + 4, y, val, config1_bits);
450: y++;
451:
452: val = PeekCONFIG2();
453: screen.Puts(0, y, "CFG2:");
454: screen.Print(x, y, "$%02x", val);
455: static const char * const config2_bits[] = {
456: "PL1", "PL0", "BSELB", "BS4", "BS3", "BS2", "BS1", "BS0"
457: };
458: MonitorReg(screen, x + 4, y, val, config2_bits);
459: y++;
460:
461: val = PeekCONFIG3();
462: screen.Puts(0, y, "CFG3:");
463: screen.Print(x, y, "$%02x", val);
464: static const char * const config3_bits[] = {
465: "PNP", "FUDUP", "LEDS1", "LEDS0", "-0", "SLEEP", "PWRDN", "ACTB"
466: };
467: MonitorReg(screen, x + 4, y, val, config3_bits);
468: y++;
469:
470: val = PeekCONFIG4();
471: screen.Puts(0, y, "CFG4:");
472: screen.Print(x, y, "$%02x", val);
473: static const char * const config4_bits[] = {
474: "-1", "-1", "-1", "-1", "-1", "-1", "-1", "IOMS"
475: };
476: MonitorReg(screen, x + 4, y, val, config4_bits);
477: y++;
478:
479: // x+ 1 2 3 4
480: // 01234567890123456789012345678901234567890123456789
481: // EEM=0(AutoLoad) Ver=3(8019A/AS) PL=0(10baseTAuto)
482: static const char * const eem_str[] = {
483: "Normal",
484: "AutoLoad",
485: "Program",
486: "WriteEn",
487: };
488: screen.Print(x, y, "EEM=%d(%s)", eem, eem_str[eem]);
489:
490: static const char * const verid_str[] = {
491: "8019A/AS",
492: "?",
493: "?",
494: "8019",
495: };
496: screen.Print(x + 16, y, "VID=%d(%s)", verid, verid_str[verid]);
497:
498: static const char * const mediatype_str[] = {
499: "10baseTAuto",
500: "10baseT",
501: "10base5",
502: "10base2",
503: };
504: screen.Print(x + 33, y, "PL=%d(%s)", mediatype, mediatype_str[mediatype]);
505: y++;
506:
507: // LED は、RTL8019AS の LED ピンではなく Nereid ボード上の LED で表す。
508: // Nereid ボードを上 (実装面側) から見るとこのような位置関係と結線に
509: // なっているため(素子は省略)、RTL8019AS の LED0,1,2 (LINK, RX, TX) と
510: // Nereid 基板上の LE1,2,3 (LINK, TX, RX) は並び順が違うことに注意。
511: //
512: // LINK TX RX
513: // (Orange) (Red) (Green)
514: // +------+
515: // +------[*]---| RJ45 |---[*]-[*]---------[USB]---+
516: // | LE1 | +------+ LE2| |LE3 |
517: // | | | |
518: // | +----------------|---|---+
519: // | | | |
520: // | +------+---+---+----+
521: // | RTL8019AS | 63 62 61 |
522: // | | LED2 LED1 LED0 |
523: // | | (TX) (RX) (LINK) |
524: //
525: y++;
526: screen.Puts(0, y, "LED:");
527: screen.Puts(x, y, TA::ReverseOrange, "LED1(LINK)");
528: screen.Puts(x + 12, y, tx_led ? TA::ReverseRed : TA::Off, "LED2(TX)");
529: screen.Puts(x + 22, y, rx_led ? TA::ReverseGreen : TA::Off, "LED3(RX)");
530:
531: // 右カラム
532: y = 0;
533: screen.Puts(x2, y++, "RSAR");
534: screen.Print(x2 - 1, y++, "(CRDA) =$%04x", PeekCRDA());
535: screen.Print(x2, y++, "RBCR =$%04x", remote_count);
536: y++;
537: //screen.Puts(x2 + 10, y, TA::Disable, "00");
538: screen.Print(x2, y++, "TPSR =$%02x", transmit_page_start_addr >> 8);
539: screen.Print(x2, y++, "TBCR =$%04x", transmit_byte_count);
540: y++;
541: //screen.Puts(x2 + 10, y, TA::Disable, "00");
542: screen.Print(x2, y++, "PSTART=$%02x", PeekPSTART());
543: //screen.Puts(x2 + 10, y, TA::Disable, "00");
544: screen.Print(x2, y++, "PSTOP =$%02x", PeekPSTOP());
545: //screen.Puts(x2 + 10, y, TA::Disable, "00");
546: screen.Print(x2, y++, "BNRY =$%02x", PeekBNRY());
547: //screen.Puts(x2 + 10, y, TA::Disable, "00");
548: screen.Print(x2, y++, "CURR =$%02x", PeekCURR());
549: y++;
550: screen.Print(x2, y++, "CLDA =$%04x", PeekCLDA());
551: y++;
552: screen.Print(x2, y++, "NCR = $%02x", PeekNCR());
553: screen.Print(x2, y++, "CNTR0 = $%02x", PeekCNTR(0));
554: screen.Print(x2, y++, "CNTR1 = $%02x", PeekCNTR(1));
555: screen.Print(x2, y++, "CNTR2 = $%02x", PeekCNTR(2));
556: }
557:
558: // レジスタをビットごとに表示する。MonitorUpdate の下請け。
559: // "-" で始まっていたら Disable 色にし、次の文字から表示。
560: void
561: RTL8019ASDevice::MonitorReg(TextScreen& screen,
562: int x, int y, uint32 reg, const char * const *names)
563: {
564: for (int i = 0; i < 8; i++) {
565: if (names[i][0] == '-') {
566: screen.Puts(x + i * 6, y, TA::Disable, names[i] + 1);
567: } else {
568: bool b = reg & (1 << (7 - i));
569: screen.Puts(x + i * 6, y, TA::OnOff(b), names[i]);
570: }
571: }
572: }
573:
574: // レジスタ読み出し (rn はページ番号込み)
575: uint32
576: RTL8019ASDevice::ReadReg(uint32 rn)
577: {
578: uint32 data;
579:
580: switch (rn) {
581: case RTL8019::CR: // CR は全ページで同じものが見える
582: case RTL8019::CR_1:
583: case RTL8019::CR_2:
584: case RTL8019::CR_3:
585: data = PeekCR();
586: break;
587:
588: case RTL8019::CLDA0:
589: data = PeekCLDA() & 0xff;
590: break;
591: case RTL8019::CLDA1:
592: data = PeekCLDA() >> 8;
593: break;
594:
595: case RTL8019::BNRY:
596: data = PeekBNRY();
597: break;
598:
599: case RTL8019::TSR:
600: data = PeekTSR();
601: break;
602:
603: case RTL8019::NCR:
604: data = PeekNCR();
605: break;
606:
607: case RTL8019::FIFO:
608: // それっぽい値は返すけど未実装
609: data = PeekFIFO();
610: putlog(0, "Read %s -> $%02x (NOT IMPLEMENTED)",
611: RegNameR(rn).c_str(), data);
612: return data;
613:
614: case RTL8019::ISR:
615: data = PeekISR();
616: break;
617:
618: case RTL8019::CRDA0:
619: data = PeekCRDA() & 0xff;
620: break;
621: case RTL8019::CRDA1:
622: data = PeekCRDA() >> 8;
623: break;
624:
625: case RTL8019::ID0:
626: data = Peek8019ID0();
627: break;
628: case RTL8019::ID1:
629: data = Peek8019ID1();
630: break;
631:
632: case RTL8019::RSR:
633: data = PeekRSR();
634: break;
635:
636: case RTL8019::CNTR0:
637: case RTL8019::CNTR1:
638: case RTL8019::CNTR2:
639: {
640: // 読み出しでリセットされる
641: int n = rn - RTL8019::CNTR0;
642: data = PeekCNTR(n);
643: error_counter[n] = 0;
644: break;
645: }
646:
647: case RTL8019::PAR0
648: ... RTL8019::PAR5:
649: data = PeekPAR(rn - RTL8019::PAR0);
650: break;
651:
652: case RTL8019::CURR:
653: data = PeekCURR();
654: break;
655:
656: case RTL8019::MAR0
657: ... RTL8019::MAR7:
658: data = PeekMAR(rn - RTL8019::MAR0);
659: break;
660:
661: case RTL8019::PSTART_2:
662: data = PeekPSTART();
663: break;
664:
665: case RTL8019::PSTOP_2:
666: data = PeekPSTOP();
667: break;
668:
669: case RTL8019::TPSR_2:
670: data = PeekTPSR();
671: break;
672:
673: case RTL8019::RCR_2:
674: data = PeekRCR();
675: break;
676:
677: case RTL8019::TCR_2:
678: data = PeekTCR();
679: break;
680:
681: case RTL8019::DCR_2:
682: data = PeekDCR();
683: break;
684:
685: case RTL8019::IMR_2:
686: data = PeekIMR();
687: break;
688:
689: case RTL8019::CR9346:
690: data = Peek9346CR();
691: break;
692:
693: case RTL8019::BPAGE:
694: data = PeekBPAGE();
695: break;
696:
697: case RTL8019::CONFIG0:
698: data = PeekCONFIG0();
699: break;
700:
701: case RTL8019::CONFIG1:
702: data = PeekCONFIG1();
703: break;
704:
705: case RTL8019::CONFIG2:
706: data = PeekCONFIG2();
707: break;
708:
709: case RTL8019::CONFIG3:
710: data = PeekCONFIG3();
711: break;
712:
713: case RTL8019::CSNSAV:
714: data = PeekCSNSAV();
715: break;
716:
717: case 0x39:
718: data = PeekReg39();
719: break;
720:
721: case RTL8019::INTR:
722: data = PeekINTR();
723: break;
724:
725: case RTL8019::CONFIG4:
726: data = PeekCONFIG4();
727: break;
728:
729: case 0x23:
730: case 0x25 ... 0x2b:
731: case 0x37:
732: case 0x3a:
733: case 0x3c:
734: case 0x3e:
735: case 0x3f:
736: data = 0xff;
737: break;
738:
739: default:
740: putlog(0, "Read %s (NOT IMPLEMENTED)", RegNameR(rn).c_str());
741: return 0xff;
742: }
743:
744: putlog(2, "%s -> $%02x", RegNameR(rn).c_str(), data);
745: return data;
746: }
747:
748: // DMA ポートのバイト読み出し
749: uint32
750: RTL8019ASDevice::ReadDMA8(uint32 a0)
751: {
752: uint32 data;
753:
754: // DMA モードが Read でない時に読み込むと、
755: // 現在の CRDA が読める (がカウンタは変化しない) ような気がする。
756:
757: uint32 prev_addr = remote_addr;
758: if (remote_addr < 0x4000) {
759: // PROM 領域。
760: // バイトアクセスだと偶数バイト、奇数バイトは同じものが見える。
761: data = ReadPROM(remote_addr);
762: } else if ((remote_addr & 0x4000)) {
763: // RAM 領域。
764: if (word_transfer || (remote_addr & 1) == 0) {
765: // WTS==1 か偶数番地なら普通に読み出せる。
766: // たぶんワードで読み出せてるがそのうち上位 (LE でいう下位)
767: // だけが見えてる状態だと思う。
768: uint16 addr = remote_addr & 0xfffe;
769: data = ReadRAM(addr);
770: } else {
771: data = 0;
772: }
773: } else {
774: // 未実装領域。実機ではバスの残像か何かが読めているようだが。
775: data = 0xff;
776: }
777: PostDMA();
778:
779: if (__predict_false(loglevel >= 2)) {
780: ReadDMAlog(prev_addr, data, 2);
781: }
782:
783: return (uint8)data;
784: }
785:
786: // DMA ポートのワード読み出し
787: uint32
788: RTL8019ASDevice::ReadDMA16()
789: {
790: uint32 data;
791:
792: // DMA モードが Read でない時に読み込むと、
793: // 現在の CRDA が読める (がカウンタは変化しない) ような気がする。
794:
795: // RTL8019AS は基本 LE で、Nereid 上でデータバスがクロスされてるはず
796: //
797: // 680x0 RTL8019AS
798: // +---------------------+ +----------------------------------+
799: // レジスタ データバス データバス (レジスタ) 内蔵メモリ
800: // +- D15-8: $86 <- - D15-8: $dd <-+ +00: $86
801: // $86dd <-+ × +- $dd86 <- +01: $dd
802: // +- D7-0 : $dd <- - D7-0 : $86 <-+
803:
804: uint32 prev_addr = remote_addr;
805: if (remote_addr < 0x4000) {
806: // PROM 領域。
807: // ワードアクセスだと上位(偶数番地)にデータ、下位(奇数番地)は $ff。
808: data = ReadPROM(remote_addr) << 8;
809: data |= 0xff;
810: } else if ((remote_addr & 0x4000)) {
811: // RAM 領域。
812: // 偶数番地からのアクセスはワード値を返す。
813: // WTS==1 なら、奇数番地でも A0 をマスクしたようにワード値を返す。
814: // WTS==0 で奇数番地ならおかしなことになる (0000 とか ffff が読める?)
815: // ようだ。
816: if (word_transfer || (remote_addr & 1) == 0) {
817: uint16 addr = remote_addr & 0xfffe;
818: data = ReadRAM(addr) << 8;
819: data |= ReadRAM(addr + 1);
820: } else {
821: data = 0;
822: }
823: } else {
824: // 未実装領域。実機ではバスの残像か何かが読めているようだが。
825: data = 0xffff;
826: }
827: PostDMA();
828:
829: if (__predict_false(loglevel >= 2)) {
830: ReadDMAlog(prev_addr, data, 4);
831: }
832:
833: return (uint16)data;
834: }
835:
836: // DMA 読み出しのログ。
837: // loglevel >= 3 なら、すべて表示。
838: // loglevel == 2 なら、受信ヘッダの読み出しと転送完了時のサマリーのみ表示。
839: // 受信ヘッダは、実際のバッファ上のデータが受信ヘッダかどうかではなく、
840: // ページ先頭から4バイトを読み出そうとしているものをヘッダの読み出しだと
841: // 思って表示する。ゲスト OS がヘッダだと思って読んだ(であろう)ところが
842: // どう読めたかが見たいので。
843: // この関数自体は loglevel >= 2 で呼ばれる。
844: void
845: RTL8019ASDevice::ReadDMAlog(uint32 prev_addr, uint32 data, int width)
846: {
847: // ページ先頭から 4 バイトの転送ならヘッダ読み込みだと思ってみる
848: bool header =
849: ((remote_start_addr & 0x00ff) == 0) && (remote_start_count == 4);
850:
851: if (loglevel >= 3 || header) {
852: std::string databuf = strhex(data, width);
853: if ((int32)data < 0) {
854: putlogn("DMA[$%04x] -> $%s (No Data)", prev_addr, databuf.c_str());
855: } else {
856: putlogn("DMA[$%04x] -> $%s", prev_addr, databuf.c_str());
857: }
858: }
859:
860: if (__predict_false(remote_count == 0)) {
861: putlogn("DMA %d bytes transferred", remote_start_count);
862: }
863: }
864:
865: // レジスタ書き込み (rn はページ番号込み)
866: uint32
867: RTL8019ASDevice::WriteReg(uint32 rn, uint32 data)
868: {
869: switch (rn) {
870: case RTL8019::CR: // CR は全ページで同じものが見える
871: case RTL8019::CR_1:
872: case RTL8019::CR_2:
873: case RTL8019::CR_3:
874: WriteCR(data);
875: return 0;
876:
877: case RTL8019::PSTART:
878: WritePSTART(data);
879: return 0;
880:
881: case RTL8019::PSTOP:
882: WritePSTOP(data);
883: return 0;
884:
885: case RTL8019::BNRY:
886: WriteBNRY(data);
887: return 0;
888:
889: case RTL8019::TPSR:
890: WriteTPSR(data);
891: return 0;
892:
893: case RTL8019::TBCR0:
894: WriteTBCR0(data);
895: return 0;
896: case RTL8019::TBCR1:
897: WriteTBCR1(data);
898: return 0;
899:
900: case RTL8019::ISR:
901: WriteISR(data);
902: return 0;
903:
904: case RTL8019::RSAR0:
905: WriteRSAR0(data);
906: return 0;
907: case RTL8019::RSAR1:
908: WriteRSAR1(data);
909: return 0;
910:
911: case RTL8019::RBCR0:
912: WriteRBCR0(data);
913: return 0;
914: case RTL8019::RBCR1:
915: WriteRBCR1(data);
916: return 0;
917:
918: case RTL8019::RCR:
919: WriteRCR(data);
920: return 0;
921:
922: case RTL8019::TCR:
923: WriteTCR(data);
924: return 0;
925:
926: case RTL8019::DCR:
927: WriteDCR(data);
928: return 0;
929:
930: case RTL8019::IMR:
931: WriteIMR(data);
932: return 0;
933:
934: case RTL8019::PAR0
935: ... RTL8019::PAR5:
936: WritePAR(rn - RTL8019::PAR0, data);
937: return 0;
938:
939: case RTL8019::CURR:
940: WriteCURR(data);
941: return 0;
942:
943: case RTL8019::MAR0
944: ... RTL8019::MAR7:
945: WriteMAR(rn - RTL8019::MAR0, data);
946: return 0;
947:
948: case RTL8019::CR9346:
949: Write9346CR(data);
950: return 0;
951:
952: case RTL8019::CONFIG0:
953: WriteCONFIG0(data);
954: return 0;
955:
956: case RTL8019::CONFIG1:
957: WriteCONFIG1(data);
958: return 0;
959:
960: case RTL8019::CONFIG2:
961: WriteCONFIG2(data);
962: return 0;
963:
964: case RTL8019::CONFIG3:
965: WriteCONFIG3(data);
966: return 0;
967:
968: default:
969: break;
970: }
971:
972: putlog(0, "%s <- $%02x (NOT IMPLEMENTED)",
973: RegNameW(rn).c_str(), data);
974: return 0xff;
975: }
976:
977: // CR レジスタ書き込み
978: void
979: RTL8019ASDevice::WriteCR(uint32 data)
980: {
981: std::string msg;
982: uint32 newpage;
983: uint32 newmode;
984: bool newstp;
985: State newstate;
986:
987: // ページ
988: newpage = (data >> 2) & 0x30;
989: if (newpage != pagesel) {
990: pagesel = newpage;
991: if (loglevel >= 2) {
992: msg = string_format(" Page=%x", pagesel >> 4);
993: }
994: }
995:
996: // DMA モード
997: newmode = (data >> 3) & 7;
998: if ((DMAMode)newmode != dmamode) {
999: dmamode = (DMAMode)newmode;
1000: if (loglevel >= 2) {
1001: msg += " DMA=";
1002: msg += GetDMAName(newmode);
1003: }
1004: }
1005:
1006: // TXP ビット
1007: if (loglevel >= 2) {
1008: if (tx_in_progress == false && (data & RTL8019::CR_TXP)) {
1009: msg += " TXP";
1010: }
1011: }
1012:
1013: // STP ビット
1014: //
1015: // 現行 STP書き込み
1016: // Normal 0 : 何もしない
1017: // InProg 0 : どうする?
1018: // Stop 0 : -> Normal へ
1019: // Normal 1 : -> InProg へ
1020: // InProg 1 : 何もしない
1021: // Stop 1 : 何もしない
1022: newstp = (data & RTL8019::CR_STP);
1023: newstate = state;
1024: if (state == State::Normal) {
1025: if (newstp) {
1026: // Normal 中に STP がセットされたらストップ状態へ移行。
1027: newstate = State::Stop;
1028: }
1029: } else {
1030: if (newstp == false) {
1031: // Stop 中に STP がクリアされたら通常状態へ移行。
1032: // Progress もこっち?
1033: newstate = State::Normal;
1034: }
1035: }
1036: if (loglevel >= 2) {
1037: if (newstate != state) {
1038: msg += string_format(" STP=%d", newstp);
1039: }
1040: }
1041:
1042: // 表示内容が揃ったところでログ表示
1043: if (loglevel >= 2) {
1044: if (msg.empty()) {
1045: putlogn("CR <- $%02x", data);
1046: } else {
1047: putlogn("CR <- $%02x (%s)", data, msg.c_str() + 1);
1048: }
1049: }
1050:
1051: if (dmamode == DMAMode::RemoteRead || dmamode == DMAMode::RemoteWrite) {
1052: // ログ用に DMA 開始時の初期値を保存
1053: remote_start_addr = remote_addr;
1054: remote_start_count = remote_count;
1055: } else if (__predict_false(dmamode == DMAMode::SendPacket)) {
1056: putlog(0, "CR: SendPacket Command (NOT IMPLEMENTED)");
1057: }
1058:
1059: // RTL8019AS では STA ビットは何もせず状態を保持してるだけ?
1060: cr_sta = (data & RTL8019::CR_STA);
1061:
1062: // XXX
1063: // NetBSD の sys/dev/ic/ne2000.c::detect_ne2000() は CR.STP を下げて、
1064: // ISR.RST が立つまで100回チェックしている。
1065: // RTL8019AS.pdf (DP83901A.pdf も) には STP を下げると ISR.RST もクリア
1066: // されると書いてあるので、このループは成立しないはず。
1067: // そして 100回試しても RST が立たなかったら検出失敗に goto するところは
1068: // (rev1.2 の時点から) if 0 されている (そりゃそれだと動かないからね…)。
1069: // 他の互換チップのことは分からんけど、
1070: // STP を下げて RST が下がるのを待つ、の間違いじゃないのかなあ。
1071:
1072: // XXX TXP と STP 同時にセットするとどうなる?
1073:
1074: // STP を立てられた時に送受信処理中でなければすぐにリセット。
1075: // 処理中のものがあればそれが終わり次第そっちで変更するので
1076: // ここでは対応不要。
1077: if (newstate != state) {
1078: ChangeState(newstate);
1079: }
1080:
1081: // 送信開始
1082: if ((data & RTL8019::CR_TXP)) {
1083: Transmit();
1084: }
1085: }
1086:
1087: // PSTART レジスタ書き込み
1088: void
1089: RTL8019ASDevice::WritePSTART(uint32 data)
1090: {
1091: putlog(2, "PSTART <- $%02x", data);
1092: pstart_addr = data << 8;
1093: }
1094:
1095: // PSTOP レジスタ書き込み
1096: void
1097: RTL8019ASDevice::WritePSTOP(uint32 data)
1098: {
1099: putlog(2, "PSTOP <- $%02x", data);
1100: pstop_addr = data << 8;
1101: }
1102:
1103: // BNRY レジスタ書き込み
1104: void
1105: RTL8019ASDevice::WriteBNRY(uint32 data)
1106: {
1107: putlog(2, "BNRY <- $%02x", data);
1108: boundary_addr = data << 8;
1109: }
1110:
1111: // TPSR レジスタ書き込み
1112: void
1113: RTL8019ASDevice::WriteTPSR(uint32 data)
1114: {
1115: putlog(2, "TPSR <- $%02x", data);
1116: transmit_page_start_addr = data << 8;
1117: }
1118:
1119: // TBCR0 レジスタ書き込み
1120: void
1121: RTL8019ASDevice::WriteTBCR0(uint32 data)
1122: {
1123: transmit_byte_count &= 0xff00;
1124: transmit_byte_count |= data;
1125:
1126: putlog(2, "TBCR0 <- $%02x (TBCR=$%04x)", data, transmit_byte_count);
1127: }
1128:
1129: // TBCR1 レジスタ書き込み
1130: void
1131: RTL8019ASDevice::WriteTBCR1(uint32 data)
1132: {
1133: transmit_byte_count &= 0x00ff;
1134: transmit_byte_count |= data << 8;
1135:
1136: putlog(2, "TBCR1 <- $%02x (TBCR=$%04x)", data, transmit_byte_count);
1137: }
1138:
1139: // ISR レジスタ書き込み
1140: void
1141: RTL8019ASDevice::WriteISR(uint32 data)
1142: {
1143: // '1' が書き込まれたビットをクリア
1144: intr_stat &= ~data;
1145: // bit7 (RST) は関係ないので落としておく
1146: intr_stat &= ~0x80;
1147:
1148: putlog(2, "ISR <- $%02x (ISR=$%02x)", data, intr_stat);
1149:
1150: ChangeInterrupt();
1151: }
1152:
1153: // RSAR0 レジスタ書き込み
1154: void
1155: RTL8019ASDevice::WriteRSAR0(uint32 data)
1156: {
1157: // RSAR への書き込みは実質 CRDA への書き込みで、両者は別のレジスタでは
1158: // なく、よくあるリードとライトで名前が違うだけのように見える。
1159: // 実際 RSAR=$4000 から $10 バイト転送後の CRDA は $4010 になっており
1160: // ここから RSAR を書き込まずにもう一度 RBCR=$10 転送すると $4010 から
1161: // の $10 バイトが読める。
1162:
1163: remote_addr &= 0xff00;
1164: remote_addr |= data;
1165:
1166: putlog(2, "RSAR0 <- $%02x (CRDA=$%04x)", data, remote_addr);
1167: }
1168:
1169: // RSAR1 レジスタ書き込み
1170: void
1171: RTL8019ASDevice::WriteRSAR1(uint32 data)
1172: {
1173: remote_addr &= 0x00ff;
1174: remote_addr |= data << 8;
1175:
1176: putlog(2, "RSAR1 <- $%02x (CRDA=$%04x)", data, remote_addr);
1177: }
1178:
1179: // RBCR0 レジスタ書き込み
1180: void
1181: RTL8019ASDevice::WriteRBCR0(uint32 data)
1182: {
1183: remote_count &= 0xff00;
1184: remote_count |= data;
1185:
1186: putlog(2, "RBCR0 <- $%02x (RBCR=$%04x)", data, remote_count);
1187: }
1188:
1189: // RBCR1 レジスタ書き込み
1190: void
1191: RTL8019ASDevice::WriteRBCR1(uint32 data)
1192: {
1193: remote_count &= 0x00ff;
1194: remote_count |= data << 8;
1195:
1196: putlog(2, "RBCR1 <- $%02x (RBCR=$%04x)", data, remote_count);
1197: }
1198:
1199: // RCR レジスタ書き込み
1200: void
1201: RTL8019ASDevice::WriteRCR(uint32 data)
1202: {
1203: putlog(2, "RCR <- $%02x", data);
1204: monitor_mode = (data & RTL8019::RCR_MON);
1205: promisc_mode = (data & RTL8019::RCR_PRO);
1206: accept_mcast = (data & RTL8019::RCR_AM);
1207: accept_bcast = (data & RTL8019::RCR_AB);
1208: accept_short = (data & RTL8019::RCR_AR);
1209: accept_error = (data & RTL8019::RCR_SEP);
1210:
1211: // プロミスキャスの設定はここで行う?
1212: hostnet->SetPromisc(promisc_mode);
1213: }
1214:
1215: // TCR レジスタ書き込み
1216: void
1217: RTL8019ASDevice::WriteTCR(uint32 data)
1218: {
1219: // OFST, ATD, LB1, CRC すべて未実装。
1220: // ループバック(LB1:0)は 0(通常), 1(内部) のみ認めておく?
1221: if ((data & 0x1d) != 0) {
1222: putlog(0, "TCR <- $%02x (NOT IMPLEMENTED)", data);
1223: } else {
1224: putlog(2, "TCR <- $%02x", data);
1225: }
1226: tcr = data;
1227: }
1228:
1229: // DCR レジスタ書き込み
1230: void
1231: RTL8019ASDevice::WriteDCR(uint32 data)
1232: {
1233: // FT は NE2000 用なので不要らしい。
1234: // LAS (ロングワード転送?) は RTL8019AS がサポートしてないらしい。
1235: // BOS (バイトオーダ選択) は RTL8019AS がサポートしてない。
1236: // ARM, LS(==0) はエミュレータ的未サポート。
1237: std::string msg;
1238: if ((data & RTL8019::DCR_ARM) != 0) {
1239: msg += "ARM=1";
1240: }
1241: if ((data & RTL8019::DCR_LS) == 0) {
1242: msg += "LS=0";
1243: }
1244: if (msg.empty() == false) {
1245: putlog(0, "DCR <- $%02x (%s NOT IMPLEMENTED)", data, msg.c_str());
1246: } else {
1247: putlog(2, "DCR <- $%02x", data);
1248: }
1249: dcr = data & 0xfe;
1250: // XXX WTS の設定と DMA ポートをアクセスする際のバス幅が一致してない
1251: // ケースは未対応。
1252: word_transfer = (data & RTL8019::DCR_WTS);
1253: }
1254:
1255: // IMR レジスタ書き込み
1256: void
1257: RTL8019ASDevice::WriteIMR(uint32 data)
1258: {
1259: putlog(2, "IMR <- $%02x", data);
1260: intr_mask = data & ~0x80;
1261: ChangeInterrupt();
1262: }
1263:
1264: // PAR0..5 レジスタ書き込み
1265: void
1266: RTL8019ASDevice::WritePAR(int n, uint32 data)
1267: {
1268: par[n] = data;
1269:
1270: if (__predict_false(loglevel >= 3)) {
1271: putlogn("PAR%d <- $%02x", n, data);
1272: } else {
1273: if (__predict_false(n == 5)) {
1274: putlog(2, "PAR <- %02x:%02x:%02x:%02x:%02x:%02x",
1275: par[0], par[1], par[2], par[3], par[4], par[5]);
1276: }
1277: }
1278: }
1279:
1280: // CURR レジスタ書き込み
1281: void
1282: RTL8019ASDevice::WriteCURR(uint32 data)
1283: {
1284: putlog(2, "CURR <- $%02x", data);
1285: current_page_addr = data << 8;
1286: local_addr = current_page_addr;
1287: }
1288:
1289: // MAR0..7 レジスタ書き込み
1290: void
1291: RTL8019ASDevice::WriteMAR(int n, uint32 data)
1292: {
1293: mar[n] = data;
1294:
1295: if (__predict_false(loglevel >= 3)) {
1296: putlogn("MAR%d <- $%02x", n, data);
1297: } else {
1298: if (__predict_false(n == 7)) {
1299: putlog(2, "MAR <- %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1300: mar[0], mar[1], mar[2], mar[3],
1301: mar[4], mar[5], mar[6], mar[7]);
1302: }
1303: }
1304: }
1305:
1306: // 9346CR レジスタ書き込み
1307: void
1308: RTL8019ASDevice::Write9346CR(uint32 data)
1309: {
1310: uint32 eem = (data >> 6) & 3;
1311:
1312: if (eem == 3) {
1313: // EEM = %11 で CONFIG1-3 への書き込みを許可。
1314: config_write_enable = true;
1315: } else {
1316: config_write_enable = false;
1317: }
1318:
1319: if (eem == 1 || eem == 2) {
1320: putlog(0, "9346CR <- $%02x EEM=%d (NOT IMPLEMENTED)", data, eem);
1321: return;
1322: }
1323: if ((data & 0x0f) != 0) {
1324: putlog(0, "9346CR <- $%02x (NOT IMPLEMENTED)", data);
1325: return;
1326: }
1327: putlog(2, "9346CR <- $%02x", data);
1328: }
1329:
1330: void
1331: RTL8019ASDevice::WriteCONFIG0(uint32 data)
1332: {
1333: if (config_write_enable == false) {
1334: putlog(1, "CONFIG0 <- $%02x: Config write is disabled", data);
1335: return;
1336: }
1337:
1338: // CONFIG0 は元々読み出し専用レジスタで、このうち VERID (2bit) で
1339: // RTL8019 のモデル情報が読み出せる構造だったっぽい。
1340: // %11 なら RTL8019
1341: // %00 なら RTL8019A
1342: // で、RTL8019AS ではこの VERID フィールドだけ R/W に変えて、
1343: // 設定によって RTL8019(無印) としても振る舞えるようにした(?)っぽい。
1344: // ほんまかいな。
1345: verid = data >> 6;
1346:
1347: if (verid != 0) {
1348: putlog(2, "CONFIG0 <- $%02x VERID=%x (NOT IMPLEMENTED)", data, verid);
1349: } else {
1350: putlog(2, "CONFIG0 <- $%02x", data);
1351: }
1352: }
1353:
1354: void
1355: RTL8019ASDevice::WriteCONFIG1(uint32 data)
1356: {
1357: if (config_write_enable == false) {
1358: putlog(1, "CONFIG1 <- $%02x: Config write is disabled", data);
1359: return;
1360: }
1361:
1362: putlog(2, "CONFIG1 <- $%02x", data);
1363: irq_enable = (data & RTL8019::CONFIG1_IRQEN);
1364: ChangeInterrupt();
1365: }
1366:
1367: void
1368: RTL8019ASDevice::WriteCONFIG2(uint32 data)
1369: {
1370: if (config_write_enable == false) {
1371: putlog(1, "CONFIG2 <- $%02x: Config write is disabled", data);
1372: return;
1373: }
1374:
1375: mediatype = (data >> 6);
1376: // どのみち BS4-0 で BROM Disabled なので、BSELB の影響は受けない。
1377: // 値だけ記憶しておく。
1378: brom_force_disable = (data & RTL8019::CONFIG2_BSELB);
1379: }
1380:
1381: void
1382: RTL8019ASDevice::WriteCONFIG3(uint32 data)
1383: {
1384: if (config_write_enable == false) {
1385: putlog(1, "CONFIG3 <- $%02x: Config write is disabled", data);
1386: return;
1387: }
1388:
1389: if ((data & 0x06) != 0) {
1390: // SLEEP, PWRDN はサポートしていない
1391: putlog(0, "CONFIG3 <- $%02x (NOT IMPLEMENTED)", data);
1392: } else {
1393: putlog(2, "CONFIG3 <- $%02x", data);
1394: }
1395: config3 = data;
1396: }
1397:
1398: // DMA ポートへのバイト書き込み
1399: void
1400: RTL8019ASDevice::WriteDMA8(uint32 data)
1401: {
1402: // DMA モードが Write でない時に書き込むとどうなる?
1403: if (dmamode != DMAMode::RemoteWrite) {
1404: putlog(0, "DMA <- $%02x but not RemoteWrite (NOT IMPLEMENTED)", data);
1405: return;
1406: }
1407:
1408: uint16 prev_addr = remote_addr;
1409: bool written;
1410: if ((remote_addr & 0x4000)) {
1411: // RAM 領域。
1412: if (word_transfer || (remote_addr & 1) == 0) {
1413: // WTS==1 か偶数番地なら書き込めそう。未確認。
1414: uint16 addr = remote_addr & 0xfffe;
1415: WriteRAM(addr, data);
1416: } else {
1417: // 未確認。
1418: }
1419: written = true;
1420: } else {
1421: // 書き込み不可。たぶん何も起きない。
1422: written = false;
1423: }
1424: PostDMA();
1425:
1426: if (__predict_false(loglevel >= 1)) {
1427: if (written) {
1428: putlog(3, "DMA[$%04x] <- $%02x", prev_addr, data);
1429: } else {
1430: putlogn("DMA[$%04x] <- $%02x (Not writable)", prev_addr, data);
1431: }
1432:
1433: if (__predict_false(remote_count == 0)) {
1434: putlog(2, "DMA %d bytes transferred", remote_start_count);
1435: }
1436: }
1437: }
1438:
1439: // DMA ポートへのワード書き込み
1440: void
1441: RTL8019ASDevice::WriteDMA16(uint32 data)
1442: {
1443: // DMA モードが Write でない時に書き込むとどうなる?
1444: if (dmamode != DMAMode::RemoteWrite) {
1445: putlog(0, "DMA <- $%04x but not RemoteWrite (NOT IMPLEMENTED)", data);
1446: return;
1447: }
1448:
1449: // RTL8019AS は基本 LE で、Nereid 上でデータバスがクロスされてるはず
1450: //
1451: // 680x0 RTL8019AS
1452: // +---------------------+ +----------------------------------+
1453: // レジスタ データバス データバス (レジスタ) 内蔵メモリ
1454: // +-> D15-8: $86 - -> D15-8: $dd -+ +00: $86
1455: // $86dd -+ × +-> $dd86 -> +01: $dd
1456: // +-> D7-0 : $dd - -> D7-0 : $86 -+
1457:
1458: uint16 prev_addr = remote_addr;
1459: bool written;
1460: if ((remote_addr & 0x4000)) {
1461: // RAM 領域。
1462: // 書き込みは確認していないが Read 側からの推測で、
1463: // 偶数番地からのアクセスは書き込めるはず。
1464: // WTS==1 なら奇数番地でも A0 をマスクしたように振る舞うはず。
1465: // WTS==0 で奇数番地ならおかしなことになりそう。
1466: if (word_transfer || (remote_addr & 1) == 0) {
1467: uint16 addr = remote_addr & 0xfffe;
1468: WriteRAM(addr, data >> 8);
1469: WriteRAM(addr + 1, data & 0xff);
1470: } else {
1471: // XXX 何が書けるかは未調査。
1472: }
1473: written = true;
1474: } else {
1475: // 書き込み不可。たぶん何も起きない。
1476: written = false;
1477: }
1478: PostDMA();
1479:
1480: if (__predict_false(loglevel >= 1)) {
1481: if (written) {
1482: putlog(3, "DMA[$%04x] <- $%04x", prev_addr, data);
1483: } else {
1484: putlogn("DMA[$%04x] <- $%04x (Not writable)", prev_addr, data);
1485: }
1486:
1487: if (__predict_false(remote_count == 0)) {
1488: putlog(2, "DMA %d bytes transferred", remote_start_count);
1489: }
1490: }
1491: }
1492:
1493: // DMA 転送後の共通処理。
1494: // アドレスをインクリメント、カウントをデクリメント。
1495: void
1496: RTL8019ASDevice::PostDMA()
1497: {
1498: // DCR.WTS==0(バイト転送) なら1回、
1499: // DCR.WTS==1(ワード転送) なら2回カウンタを進める。
1500: // その都度 0 チェックは行う。
1501:
1502: // カウンタが 0 でも、1回今の remote_addr からの読み出しは出来て、
1503: // ただしそれ以上は進まないので、ここにカウンタのチェックがあるっぽい。
1504: //
1505: // 実機でも、
1506: // 1. RSAR=$4000、RBCR=$0008 をセットして CR <- RemoteDMA
1507: // -> $4000 から 8バイト読み出せて CRDA=$4008
1508: // 2. CR <- RemoteDMA
1509: // -> $4008 から 1ワード(1回)読み出せて CRDA=$4008
1510: // 3. RBCR=$0008 をセットして CR <- RemoteDMA
1511: // -> $4008 から 8バイト読み出せる。
1512: // となる。
1513:
1514: int n;
1515:
1516: if (word_transfer) {
1517: n = 2;
1518: } else {
1519: n = 1;
1520: }
1521:
1522: for (int i = 0; remote_count > 0 && i < n; i++) {
1523: remote_count--;
1524: remote_addr++;
1525: if (__predict_false(remote_addr == pstop_addr)) {
1526: remote_addr = pstart_addr;
1527: }
1528: }
1529:
1530: if (__predict_false(remote_count == 0)) {
1531: dmamode = DMAMode::Complete;
1532: intr_stat |= RTL8019::ISR_RDC;
1533: ChangeInterrupt();
1534: }
1535: }
1536:
1537: uint32
1538: RTL8019ASDevice::PeekReg(uint32 rn) const
1539: {
1540: switch (rn) {
1541: case RTL8019::CR: // CR は全ページで同じものが見える
1542: case RTL8019::CR_1:
1543: case RTL8019::CR_2:
1544: case RTL8019::CR_3:
1545: return PeekCR();
1546:
1547: case RTL8019::CLDA0:
1548: return PeekCLDA() & 0xff;
1549: case RTL8019::CLDA1:
1550: return PeekCLDA() >> 8;
1551:
1552: case RTL8019::BNRY:
1553: return PeekBNRY();
1554:
1555: case RTL8019::TSR:
1556: return PeekTSR();
1557:
1558: case RTL8019::NCR:
1559: return PeekNCR();
1560:
1561: case RTL8019::FIFO:
1562: return PeekFIFO();
1563:
1564: case RTL8019::ISR:
1565: return PeekISR();
1566:
1567: case RTL8019::CRDA0:
1568: return PeekCRDA() & 0xff;
1569: case RTL8019::CRDA1:
1570: return PeekCRDA() >> 8;
1571:
1572: case RTL8019::ID0:
1573: return Peek8019ID0();
1574: case RTL8019::ID1:
1575: return Peek8019ID1();
1576:
1577: case RTL8019::RSR:
1578: return PeekRSR();
1579:
1580: case RTL8019::CNTR0:
1581: return PeekCNTR(0);
1582: case RTL8019::CNTR1:
1583: return PeekCNTR(1);
1584: case RTL8019::CNTR2:
1585: return PeekCNTR(2);
1586:
1587: case RTL8019::PAR0
1588: ... RTL8019::PAR5:
1589: return PeekPAR(rn - RTL8019::PAR0);
1590:
1591: case RTL8019::CURR:
1592: return PeekCURR();
1593:
1594: case RTL8019::MAR0
1595: ... RTL8019::MAR7:
1596: return PeekMAR(rn - RTL8019::MAR0);
1597:
1598: case RTL8019::PSTART_2:
1599: return PeekPSTART();
1600:
1601: case RTL8019::PSTOP_2:
1602: return PeekPSTOP();
1603:
1604: case RTL8019::TPSR_2:
1605: return PeekTPSR();
1606:
1607: case RTL8019::RCR_2:
1608: return PeekRCR();
1609:
1610: case RTL8019::TCR_2:
1611: return PeekTCR();
1612:
1613: case RTL8019::DCR_2:
1614: return PeekDCR();
1615:
1616: case RTL8019::IMR_2:
1617: return PeekIMR();
1618:
1619: case RTL8019::CR9346:
1620: return Peek9346CR();
1621:
1622: case RTL8019::BPAGE:
1623: return PeekBPAGE();
1624:
1625: case RTL8019::CONFIG0:
1626: return PeekCONFIG0();
1627:
1628: case RTL8019::CONFIG1:
1629: return PeekCONFIG1();
1630:
1631: case RTL8019::CONFIG2:
1632: return PeekCONFIG2();
1633:
1634: case RTL8019::CONFIG3:
1635: return PeekCONFIG3();
1636:
1637: case RTL8019::CSNSAV:
1638: return PeekCSNSAV();
1639:
1640: case 0x39:
1641: return PeekReg39();
1642:
1643: case RTL8019::INTR:
1644: return PeekINTR();
1645:
1646: case RTL8019::CONFIG4:
1647: return PeekCONFIG4();
1648: }
1649: return 0xff;
1650: }
1651:
1652: uint32
1653: RTL8019ASDevice::PeekCR() const
1654: {
1655: uint32 data;
1656:
1657: // PS
1658: data = pagesel << 2;
1659:
1660: // RD
1661: switch (dmamode) {
1662: case DMAMode::NotAllowed:
1663: break;
1664: case DMAMode::RemoteRead:
1665: data |= RTL8019::CR_RD_READ;
1666: break;
1667: case DMAMode::RemoteWrite:
1668: data |= RTL8019::CR_RD_WRITE;
1669: break;
1670: case DMAMode::SendPacket:
1671: data |= RTL8019::CR_RD_SEND;
1672: break;
1673: case DMAMode::Complete:
1674: data |= 0x20;
1675: break;
1676: }
1677:
1678: // TXP
1679: if (tx_in_progress) {
1680: data |= RTL8019::CR_TXP;
1681: }
1682:
1683: // STA
1684: data |= cr_sta;
1685:
1686: // STP
1687: if (state == State::Stop) {
1688: data |= RTL8019::CR_STP;
1689: }
1690:
1691: return data;
1692: }
1693:
1694: uint32
1695: RTL8019ASDevice::PeekCLDA() const
1696: {
1697: return local_addr;
1698: }
1699:
1700: uint32
1701: RTL8019ASDevice::PeekBNRY() const
1702: {
1703: return boundary_addr >> 8;
1704: }
1705:
1706: uint32
1707: RTL8019ASDevice::PeekTSR() const
1708: {
1709: uint32 data = tsr;
1710:
1711: // bit5 は %0、bit1 は %1 らしい。
1712: data &= ~0x20;
1713: data |= 0x02;
1714:
1715: return data;
1716: }
1717:
1718: uint32
1719: RTL8019ASDevice::PeekNCR() const
1720: {
1721: // コリジョンカウンタは不要なので実装していない
1722: return 0;
1723: }
1724:
1725: uint32
1726: RTL8019ASDevice::PeekFIFO() const
1727: {
1728: // 未実装だが $00 が読めているようだ
1729: return 0;
1730: }
1731:
1732: uint32
1733: RTL8019ASDevice::PeekISR() const
1734: {
1735: uint32 data = intr_stat;
1736:
1737: // RST は、Stop 状態とバッファフルの論理和?
1738: if (state == State::Stop || local_addr == boundary_addr) {
1739: data |= RTL8019::ISR_RST;
1740: }
1741:
1742: return data;
1743: }
1744:
1745: uint32
1746: RTL8019ASDevice::PeekCRDA() const
1747: {
1748: return remote_addr;
1749: }
1750:
1751: uint32
1752: RTL8019ASDevice::Peek8019ID0() const
1753: {
1754: return 0x50;
1755: }
1756:
1757: uint32
1758: RTL8019ASDevice::Peek8019ID1() const
1759: {
1760: return 0x70;
1761: }
1762:
1763: uint32
1764: RTL8019ASDevice::PeekRSR() const
1765: {
1766: uint32 data;
1767:
1768: data = rsr & ~0x48;
1769: if (monitor_mode) {
1770: data |= RTL8019::RSR_DIS;
1771: }
1772:
1773: return data;
1774: }
1775:
1776: uint32
1777: RTL8019ASDevice::PeekCNTR(int n) const
1778: {
1779: return error_counter[n];
1780: }
1781:
1782: uint32
1783: RTL8019ASDevice::PeekPAR(int n) const
1784: {
1785: return par[n];
1786: }
1787:
1788: uint32
1789: RTL8019ASDevice::PeekCURR() const
1790: {
1791: return current_page_addr >> 8;
1792: }
1793:
1794: uint32
1795: RTL8019ASDevice::PeekMAR(int n) const
1796: {
1797: return mar[n];
1798: }
1799:
1800: uint32
1801: RTL8019ASDevice::PeekPSTART() const
1802: {
1803: return pstart_addr >> 8;
1804:
1805: }
1806:
1807: uint32
1808: RTL8019ASDevice::PeekPSTOP() const
1809: {
1810: return pstop_addr >> 8;
1811: }
1812:
1813: uint32
1814: RTL8019ASDevice::PeekTPSR() const
1815: {
1816: return transmit_page_start_addr >> 8;
1817: }
1818:
1819: uint32
1820: RTL8019ASDevice::PeekRCR() const
1821: {
1822: uint32 data = 0xc0;
1823:
1824: if (monitor_mode) data |= RTL8019::RCR_MON;
1825: if (promisc_mode) data |= RTL8019::RCR_PRO;
1826: if (accept_mcast) data |= RTL8019::RCR_AM;
1827: if (accept_bcast) data |= RTL8019::RCR_AB;
1828: if (accept_short) data |= RTL8019::RCR_AR;
1829: if (accept_error) data |= RTL8019::RCR_SEP;
1830:
1831: return data;
1832: }
1833:
1834: uint32
1835: RTL8019ASDevice::PeekTCR() const
1836: {
1837: return 0xe0 | tcr;
1838: }
1839:
1840: uint32
1841: RTL8019ASDevice::PeekDCR() const
1842: {
1843: uint32 data;
1844:
1845: data = 0x80 | dcr;
1846: if (word_transfer) data |= RTL8019::DCR_WTS;
1847:
1848: return data;
1849: }
1850:
1851: uint32
1852: RTL8019ASDevice::PeekIMR() const
1853: {
1854: return intr_mask | 0x80;
1855: }
1856:
1857: uint32
1858: RTL8019ASDevice::Peek9346CR() const
1859: {
1860: uint32 data = 0x30;
1861:
1862: // EEM は $0 か $3 のみサポート
1863: if (config_write_enable) {
1864: data |= 0xc0;
1865: }
1866:
1867: return data;
1868: }
1869:
1870: uint32
1871: RTL8019ASDevice::PeekBPAGE() const
1872: {
1873: // 使わなそうだし、サポートもしていない
1874: return 0;
1875: }
1876:
1877: uint32
1878: RTL8019ASDevice::PeekCONFIG0() const
1879: {
1880: // XXX 値確認
1881: return (verid << 6);
1882: }
1883:
1884: uint32
1885: RTL8019ASDevice::PeekCONFIG1() const
1886: {
1887: uint32 data;
1888:
1889: // IRQS=INT1、IOS=300H
1890: data = 0x10;
1891: if (irq_enable) data |= RTL8019::CONFIG1_IRQEN;
1892:
1893: return data;
1894: }
1895:
1896: uint32
1897: RTL8019ASDevice::PeekCONFIG2() const
1898: {
1899: uint32 data;
1900:
1901: data = mediatype << 6;
1902: if (brom_force_disable) {
1903: data |= RTL8019::CONFIG2_BSELB;
1904: }
1905: // BS4-0 は 0
1906:
1907: return data;
1908: }
1909:
1910: uint32
1911: RTL8019ASDevice::PeekCONFIG3() const
1912: {
1913: uint32 data;
1914:
1915: data = (config3 & 0x06);
1916:
1917: // LEDS1=0, LEDS0=1
1918: data |= 0x10;
1919:
1920: return data;
1921: }
1922:
1923: uint32
1924: RTL8019ASDevice::PeekCSNSAV() const
1925: {
1926: // サポートしていない
1927: return 0;
1928: }
1929:
1930: uint32
1931: RTL8019ASDevice::PeekReg39() const
1932: {
1933: // データシートには何もないと書いてあるが $fe が読めるようだ
1934: return 0xfe;
1935: }
1936:
1937: uint32
1938: RTL8019ASDevice::PeekCONFIG4() const
1939: {
1940: // IOMS=0
1941: return 0xfe;
1942: }
1943:
1944: uint32
1945: RTL8019ASDevice::PeekINTR() const
1946: {
1947: // INT1 以外は pull up?
1948: uint32 data = 0xfd;
1949:
1950: // 正論理でええんやろうか
1951: if (interrupt->GetINT(this)) {
1952: data |= 0x02;
1953: }
1954:
1955: return data;
1956: }
1957:
1958: uint32
1959: RTL8019ASDevice::PeekDMA(uint32 a0) const
1960: {
1961: // DMA モードが Read でない時には何を見せる?
1962: if (dmamode != DMAMode::RemoteRead) {
1963: if (a0 == 0) {
1964: return 0xcc;
1965: } else {
1966: return 0xdd;
1967: }
1968: }
1969:
1970: // このポートは実際にはバイトアクセスかワードアクセスかによって
1971: // (か、もしくは DCR.WTS ビットによって?)、
1972: // 読み出せる値が変わるが、実用上はワード転送がメインだろうと思うので、
1973: // 正しくワードアクセスされたと仮定した時の値を表示しておく。
1974: if (remote_addr < 0x4000) {
1975: if (a0 == 0) {
1976: return ReadPROM(remote_addr);
1977: } else {
1978: return 0xff;
1979: }
1980: } else if ((remote_addr & 0x4000)) {
1981: uint32 addr = remote_addr & ~1;
1982: return ReadRAM(addr + a0);
1983: } else {
1984: return 0xff;
1985: }
1986: }
1987:
1988:
1989: // PROM 領域をバイトで読み出す。
1990: // addr は内蔵メモリ空間でのアドレス。
1991: uint32
1992: RTL8019ASDevice::ReadPROM(uint32 addr) const
1993: {
1994: // PROM 領域は 32 バイト(16ワード) でミラー。
1995: uint32 offset = (addr >> 1) & 0x0f;
1996: assert(offset < prom.size());
1997: return prom[offset];
1998: }
1999:
2000: // 内蔵 RAM を (副作用なく) バイトで読み出す。
2001: // addr は内蔵メモリ空間でのアドレス。
2002: // 送信パケット用の読み出しにも使われる。
2003: inline uint32
2004: RTL8019ASDevice::ReadRAM(uint32 addr) const
2005: {
2006: uint32 offset = addr & 0x3fff;
2007: assert(offset < buffer.size());
2008: return buffer[offset];
2009: }
2010:
2011: // 内蔵 RAM に (副作用なく) バイトで書き込む。
2012: // addr は内蔵メモリ空間でのアドレス。
2013: // 受信パケットの書き込みにも使われる。
2014: inline void
2015: RTL8019ASDevice::WriteRAM(uint32 addr, uint32 data)
2016: {
2017: uint32 offset = addr & 0x3fff;
2018: assert(offset < buffer.size());
2019: buffer[offset] = data;
2020: }
2021:
2022:
2023: // 動作状態が Stop か StopInProgress なら true を返す
2024: bool
2025: RTL8019ASDevice::IsStopOrInProgress() const
2026: {
2027: return (state != State::Normal);
2028: }
2029:
2030: // 動作状態を newstate に変更を試みる。
2031: // newstate には Normal か Stop を指定すること
2032: // (その結果 StopInProgress になるかも知れない)。
2033: void
2034: RTL8019ASDevice::ChangeState(State newstate)
2035: {
2036: if (newstate == state) {
2037: return;
2038: }
2039:
2040: switch (newstate) {
2041: case State::Normal:
2042: hostnet->SetMyAddr(par);
2043: hostnet->EnableRx(true);
2044: break;
2045:
2046: case State::Stop:
2047: if (tx_in_progress || rx_packet.length != 0) {
2048: // 処理中があれば、処理が終わるのを待つ。
2049: // (送信または受信処理完了時に Stop にする)
2050: newstate = State::StopInProgress;
2051: } else {
2052: // ホストの受信を停止する
2053: hostnet->EnableRx(false);
2054: }
2055: break;
2056:
2057: default:
2058: break;
2059: }
2060: state = newstate;
2061: }
2062:
2063: // 送信開始。
2064: void
2065: RTL8019ASDevice::Transmit()
2066: {
2067: // Stop なら送(受)信は不可。
2068: // InProgress でも新たな送信は行わない
2069: // (受信完了を待ってるところのかもしれないので)。
2070: if (IsStopOrInProgress()) {
2071: putlog(1, "Transmit not allowed due to CR.STP=1");
2072: return;
2073: }
2074:
2075: // 送信開始
2076: putlog(2, "Transmit TPSR=$%02x TBCR=$%04x",
2077: transmit_page_start_addr >> 8, transmit_byte_count);
2078:
2079: tx_packet.Clear();
2080: tx_in_progress = true;
2081:
2082: // TSR は転送開始時にクリア (DP83901A.pdf)
2083: tsr = 0;
2084:
2085: // 転送イベントを起こすだけ。
2086: tx_event.time = 0;
2087: scheduler->StartEvent(tx_event);
2088:
2089: // LED イベントは止まっていれば動かす。
2090: if (txled_event.IsRunning() == false) {
2091: txled_event.time = 0;
2092: scheduler->StartEvent(txled_event);
2093: }
2094: }
2095:
2096: // 転送イベント。
2097: // TXP=1 で呼ばれて、ページごとにパケットにコピーする。
2098: // TBCR で指定された長さを全部コピーしたらホストに送信。
2099: void
2100: RTL8019ASDevice::TXEvent(Event& event)
2101: {
2102: // 今回処理する分
2103: int count = std::min((uint)transmit_byte_count, 256u);
2104: if (count == 0 && tx_packet.length != 0) {
2105: // 前回でコピーが完了していればここで送信。
2106: putlog(3, "TXEvent Send %d bytes", tx_packet.length);
2107: hostnet->Tx(tx_packet);
2108:
2109: // 送信完了。
2110: tx_in_progress = false;
2111: tsr |= RTL8019::TSR_PTX;
2112: intr_stat |= RTL8019::ISR_PTX;
2113: ChangeInterrupt();
2114:
2115: // ストップ待ちなら、ストップ状態に移行を試みる
2116: if (state == State::StopInProgress) {
2117: ChangeState(State::Stop);
2118: }
2119: return;
2120: }
2121:
2122: // このページをパケットにコピー
2123: uint32 addr = transmit_page_start_addr;
2124: for (uint32 end = addr + count; addr < end; addr++) {
2125: tx_packet.Append((uint8)ReadRAM(addr));
2126: }
2127: putlog(4, "TXEvent Copy %d bytes at page $%02x",
2128: count, transmit_page_start_addr >> 8);
2129:
2130: // XXX TPSR, TBCR は更新されるのかどうか。
2131: // とりあえず内部で必要なので使いまわしておく。
2132: transmit_page_start_addr += 256;
2133: transmit_byte_count -= count;
2134: // XXX 折り返し
2135:
2136: // 転送にかかった時間を模しておく。
2137: // 時間は適当。10Mbps なので 1バイトあたり 1usec とする。
2138: tx_event.time = count * 1_usec;
2139: scheduler->StartEvent(tx_event);
2140: }
2141:
2142: // パケット受信通知。HostNet から呼ばれる。
2143: void
2144: RTL8019ASDevice::HostRxCallback(MessageID msgid, uint32 arg)
2145: {
2146: // 受信イベントが止まっていれば動かす。
2147: // 受信イベントがすでに動いていれば、1パケット受信完了後に
2148: // ホストキューを確認するので、ここでは何もしなくてよい。
2149: if (rx_event.IsRunning() == false) {
2150: rx_event.time = 0;
2151: scheduler->StartEvent(rx_event);
2152: }
2153: }
2154:
2155: // 受信イベント。
2156: //
2157: // rx_packet の length, remain によって状態マシンになっている。
2158: //
2159: // len == 0 : 受信中でない。ホストキューから読み出せる
2160: // len != 0, remain == len : 受信パケットのコピー (1ページ目)。ヘッダも出力
2161: // len != 0, remain < len : 受信パケットのコピー (2ページ目以降)
2162: // len != 0, remain == 0 : 受信パケットのコピー完了直後。
2163: void
2164: RTL8019ASDevice::RXEvent(Event& event)
2165: {
2166: int remain;
2167:
2168: if (rx_packet.length == 0) {
2169: // パケットが空の時に呼ばれたら、
2170: // ホストキューから1パケット取り出してみる。
2171: if (hostnet->Rx(&rx_packet) == false) {
2172: // 取り出せなくなったら、ここでイベントを停止。
2173: rx_packet.Clear();
2174: return;
2175: }
2176:
2177: // 取り出したらそのまま処理する。
2178: // ここがパケット受信処理開始なので RSR をクリア。
2179: rsr = 0;
2180:
2181: // 受信 LED イベントが止まっていれば動かす。
2182: // 取り出して、破棄するかもしれないより前。
2183: if (rxled_event.IsRunning() == false) {
2184: rxled_event.time = 0;
2185: scheduler->StartEvent(rxled_event);
2186: }
2187:
2188: // 受信無効中ならカウンタを上げてから、パケットを破棄。
2189: if (monitor_mode) {
2190: rsr |= RTL8019::RSR_MPA;
2191: rsr &= ~RTL8019::RSR_PRX; // 念のため
2192: IncCounter(2);
2193:
2194: intr_stat |= RTL8019::ISR_RXE;
2195: ChangeInterrupt();
2196:
2197: goto discard;
2198: }
2199: }
2200:
2201: assert(rx_packet.length != 0);
2202: remain = rx_packet.GetRemain();
2203: if (remain != 0) {
2204: // 実際に書き込む前に、これから書き込むページ(local_addr) が
2205: // BNRY (ホストがまだ読んでない受信済みページ に追いついていたら、
2206: // 受信バッファオーバーフロー。
2207: if (local_addr == boundary_addr) {
2208: putlog(2, "Receive ring overflow: CURR=$%02x BNRY=$%02x",
2209: local_addr >> 8, boundary_addr >> 8);
2210:
2211: rsr |= RTL8019::RSR_MPA;
2212: rsr &= ~RTL8019::RSR_PRX; // 念のため
2213: IncCounter(2);
2214:
2215: // RST は自動的にセットされる
2216: intr_stat |= RTL8019::ISR_OVW | RTL8019::ISR_RXE;
2217: ChangeInterrupt();
2218:
2219: goto discard;
2220: }
2221:
2222: if (remain == rx_packet.length) {
2223: // 初回処理
2224: RXHead(remain);
2225: }
2226: RXCopy(event, remain);
2227: } else {
2228: RXDone(event);
2229: }
2230: return;
2231:
2232: discard:
2233: // パケットを破棄する。
2234: // この場合も、ホストキューから次のパケットを引き取る作業は必要。
2235: // XXX 間隔は適当
2236: rx_packet.Clear();
2237: event.time = 1_usec;
2238: scheduler->RestartEvent(event);
2239: }
2240:
2241: // パケット受信の初回。
2242: // 4バイトの受信ヘッダをバッファに書き込む。
2243: void
2244: RTL8019ASDevice::RXHead(int remain)
2245: {
2246: // 先に、このパケットの次のページ位置を求めて覚えておく。
2247: next_page_addr = local_addr + 4 + rx_packet.length;
2248: next_page_addr = roundup(next_page_addr, 256);
2249: if (next_page_addr >= pstop_addr) {
2250: next_page_addr = pstart_addr + (next_page_addr - pstop_addr);
2251: }
2252:
2253: // 受信ヘッダは転送完了後に書き込むため、空けておく。
2254: // XXX ゼロクリアするかどうか
2255: local_addr += 4;
2256: }
2257:
2258: // 受信パケットをバッファにコピー。
2259: // 1ページ埋めるかパケットをコピーし終えたら次へ。
2260: // (初回もヘッダ書き込みに続いて呼ばれる)
2261: void
2262: RTL8019ASDevice::RXCopy(Event& event, int remain)
2263: {
2264: // パケットをこのページにコピー。
2265: // 今回処理する分はパケットの残りとページの残りの小さいほう。
2266: int count = std::min(remain, 0x100 - (local_addr & 0xff));
2267: putlog(4, "RXEvent Copy %d bytes at page $%02x", count, local_addr >> 8);
2268: for (uint32 end = local_addr + count; local_addr < end; ) {
2269: WriteRAM(local_addr++, rx_packet.Read());
2270: }
2271:
2272: // パケットの最後に到達したらポインタだけここで次ページへ。
2273: // PSTOP 折り返し処理の前にやっておくため。
2274: // (パケットの受信完了処理自体は次のループの先頭で行う)
2275: if (rx_packet.GetRemain() == 0) {
2276: local_addr = roundup(local_addr, 256);
2277: }
2278:
2279: // PSTOP に到達したら PSTART に折り返す。
2280: if (local_addr >= pstop_addr) {
2281: local_addr = pstart_addr;
2282: }
2283:
2284: // 転送にかかった時間を模しておく。
2285: // 時間は適当。10Mbps なので 1バイトあたり 1usec とする。
2286: event.time = count * 1_usec;
2287: scheduler->RestartEvent(event);
2288: }
2289:
2290: // 受信パケットをバッファにコピーし終えた次のターンで呼ばれる。
2291: // 完了処理をして、ストップ待ちならストップ状態に移行。
2292: // ストップ待ちでなければ再び RXEvent() イベントを呼び、
2293: // 次パケットの処理を継続する。
2294: void
2295: RTL8019ASDevice::RXDone(Event& event)
2296: {
2297: // 前回でコピーが完了していればここで通知。
2298: putlog(3, "RXDone Received %d bytes", rx_packet.length);
2299:
2300: // 受信ヘッダに書き込む前に RSR を更新
2301: rsr |= RTL8019::RSR_PRX;
2302: // 念のためエラービットをクリア (DP83901A.pdf)
2303: rsr &= ~(RTL8019::RSR_MPA |
2304: RTL8019::RSR_FAE |
2305: RTL8019::RSR_CRC);
2306:
2307: // XXX Receive Status には、正常受信時は RSR を書き込む。
2308: // エラー時はまだ見てない (DP83901A.pdf)
2309:
2310: // 受信ヘッダを書き込む。
2311: // このパケット受信中は CURR は更新しないので、これが使える。
2312: //
2313: // メモリ上のバイト順で次の通り。
2314: // +0: Receive Status
2315: // +1: 次の受信ページ
2316: // +2: 受信バイト長(L)
2317: // +3: 受信バイト長(H)
2318: //
2319: // ワード (Little Endian) 表記:
2320: // D15 D8 D7 D0
2321: // +0: 次の受信ページ Receive Status
2322: // +2: 受信バイト長(H) 受信バイト長(L)
2323: uint16 addr = current_page_addr;
2324: WriteRAM(addr++, rsr);
2325: WriteRAM(addr++, next_page_addr >> 8);
2326: WriteRAM(addr++, rx_packet.length & 0xff);
2327: WriteRAM(addr++, rx_packet.length >> 8);
2328:
2329: // CURR を次受信ページに更新。残り転送バイトが 0 になった時点で
2330: // local_addr は次ページ先頭に繰り上げてある。
2331: current_page_addr = local_addr;
2332:
2333: rx_packet.Clear();
2334:
2335: // 受信完了。
2336: intr_stat |= RTL8019::ISR_PRX;
2337: ChangeInterrupt();
2338:
2339: if (state == State::StopInProgress) {
2340: // ストップ待ちなら、ストップ状態に移行を試みる
2341: ChangeState(State::Stop);
2342: } else {
2343: // そうでなければ、次の受信を試す。
2344: // (rx_packet.length == 0 で RXEvent() を呼ぶとパケット受信となる)
2345:
2346: // どのくらいか待つ? 値は適当
2347: event.time = 100_usec;
2348: scheduler->RestartEvent(event);
2349: }
2350: }
2351:
2352: // 送信 LED イベント
2353: void
2354: RTL8019ASDevice::TXLedEvent(Event& event)
2355: {
2356: if (tx_led == false) {
2357: // 消灯中だったら、次は 6msec 点灯
2358: tx_led = true;
2359: event.time = 6_msec;
2360: scheduler->RestartEvent(event);
2361: } else {
2362: // 点灯中だったら
2363: // - 送信中なら次は 100msec 消灯
2364: // - 送信中でなければここで終わり
2365: if (tx_in_progress) {
2366: tx_led = false;
2367: event.time = 100_msec;
2368: scheduler->RestartEvent(event);
2369: }
2370: }
2371: }
2372:
2373: // 受信 LED イベント
2374: void
2375: RTL8019ASDevice::RXLedEvent(Event& event)
2376: {
2377: if (rx_led == false) {
2378: // 消灯中だったら、次は 6msec 点灯
2379: rx_led = true;
2380: event.time = 6_msec;
2381: scheduler->RestartEvent(event);
2382: } else {
2383: // 点灯中だったら
2384: // - 受信中なら次は 100msec 消灯
2385: // - 受信中でなければここで終わり
2386: if (rx_packet.length != 0) {
2387: rx_led = false;
2388: event.time = 100_msec;
2389: scheduler->RestartEvent(event);
2390: }
2391: }
2392: }
2393:
2394:
2395: // 実際のボードの割り込みは、SL811HS/T もいるので NereidBoard が一旦受けて
2396: // いると思うが、それを忠実に真似すると
2397: // RTL8019AS -> NereidBoard -> X68030Interrupt のようなカスケードになり、
2398: // それはちょっと手間なので、ここでは NereidBoard の DIPSW で決まる割り込み
2399: // ベクタの値だけ NereidBoard から事前に受け取っておいて、あとは
2400: // InterruptDevice と直接やりとりする。
2401:
2402: // 割り込み信号線の状態を変える。
2403: // intr_stat、intr_mask、irq_enable が更新されたら呼ぶこと。
2404: void
2405: RTL8019ASDevice::ChangeInterrupt()
2406: {
2407: if (irq_enable) {
2408: if ((intr_stat & intr_mask) != 0) {
2409: interrupt->AssertINT(this);
2410: } else {
2411: interrupt->NegateINT(this);
2412: }
2413: } else {
2414: // IRQEN が 0 だと出力がハイインピーダンスになる。
2415: interrupt->AssertINT(this);
2416: }
2417: }
2418:
2419: // 割り込みアクノリッジ
2420: int
2421: RTL8019ASDevice::InterruptAcknowledge()
2422: {
2423: return intr_vector;
2424: }
2425:
2426: // エラーカウンタをインクリメントする。
2427: void
2428: RTL8019ASDevice::IncCounter(int n)
2429: {
2430: error_counter[n]++;
2431:
2432: // XXX DP83901A はカウンタが $c0 になったらカウントとめるらしい。
2433: // RTL8019AS/AX88196B には記述なし。要動作確認。
2434:
2435: // いずれかカウンタの MSB が立ったら割り込み
2436: uint32 c = error_counter[0] | error_counter[1] | error_counter[2];
2437: if ((c & 0x80) != 0) {
2438: intr_stat |= RTL8019::ISR_CNT;
2439: } else {
2440: // 書いてはないけど、たぶん OR したのが繋がってるだけだとしたら
2441: // 最上位ビットがいずれも立たなくなったら、CNT も勝手に下がるはず?
2442: intr_stat &= ~RTL8019::ISR_CNT;
2443: }
2444: ChangeInterrupt();
2445: }
2446:
2447: // 読み込み時のレジスタ名を返す (rn はページ番号込み)
2448: /*static*/ std::string
2449: RTL8019ASDevice::RegNameR(int rn)
2450: {
2451: if (regnames[rn]) {
2452: return std::string(regnames[rn]);
2453: } else {
2454: return string_format("(%02x)", rn);
2455: }
2456: }
2457:
2458: // 書き込み時のレジスタ名を返す (rn はページ番号込み)
2459: /*static*/ std::string
2460: RTL8019ASDevice::RegNameW(int rn)
2461: {
2462: int page = rn >> 4;
2463: int n = rn & 0xf;
2464:
2465: // Page1 は R/W 共通
2466: if (page == 1) {
2467: return RegNameR(rn);
2468: }
2469:
2470: // Page2 は ReadOnly レジスタなので名前はない。
2471: if (page == 2) {
2472: return string_format("%02x", rn);
2473: }
2474:
2475: // Page0, Page3 のレジスタ名はオフセットしたところに置いてある。
2476: int offset = (page == 0) ? 0x40 : 0x50;
2477: if (regnames[offset + n]) {
2478: return std::string(regnames[offset + n]);
2479: } else {
2480: return string_format("(%02x)", rn);
2481: }
2482: }
2483:
2484: /*static*/ const char * const
2485: RTL8019ASDevice::regnames[] = {
2486: "CR", // 0 Page0(Read側)
2487: "CLDA0", // 1
2488: "CLDA1", // 2
2489: "BNRY", // 3
2490: "TSR", // 4
2491: "NCR", // 5
2492: "FIFO", // 6
2493: "ISR", // 7
2494: "CRDA0", // 8
2495: "CRDA1", // 9
2496: "8019ID0", // a
2497: "8019ID1", // b
2498: "RSR", // c
2499: "CNTR0", // d
2500: "CNTR1", // e
2501: "CNTR2", // f
2502:
2503: "CR", // 0 Page1(R/W共通)
2504: "PAR0", // 1
2505: "PAR1", // 2
2506: "PAR2", // 3
2507: "PAR3", // 4
2508: "PAR4", // 5
2509: "PAR5", // 6
2510: "CURR", // 7
2511: "MAR0", // 8
2512: "MAR1", // 9
2513: "MAR2", // a
2514: "MAR3", // b
2515: "MAR4", // c
2516: "MAR5", // d
2517: "MAR6", // e
2518: "MAR7", // f
2519:
2520: "CR", // 0 Page2(Read Only)
2521: "PSTART", // 1
2522: "PSTOP", // 2
2523: NULL, // 3
2524: "TPSR", // 4
2525: NULL, // 5
2526: NULL, // 6
2527: NULL, // 7
2528: NULL, // 8
2529: NULL, // 9
2530: NULL, // a
2531: NULL, // b
2532: "RCR", // c
2533: "TCR", // d
2534: "DCR", // e
2535: "IMR", // f
2536:
2537: "CR", // 0 Page3(Read側)
2538: "9346CR", // 1
2539: "BPAGE", // 2
2540: "CONFIG0", // 3
2541: "CONFIG1", // 4
2542: "CONFIG2", // 5
2543: "CONFIG3", // 6
2544: NULL, // 7
2545: "CSNSAV", // 8
2546: NULL, // 9
2547: NULL, // a
2548: "INTR", // b
2549: NULL, // c
2550: "CONFIG4", // d
2551: NULL, // e
2552: NULL, // f
2553:
2554: "CR", // 0 Page0(Write側)
2555: "PSTART", // 1
2556: "PSTOP", // 2
2557: "BNRY", // 3
2558: "TPSR", // 4
2559: "TBCR0", // 5
2560: "TBCR1", // 6
2561: "ISR", // 7
2562: "RSAR0", // 8
2563: "RSAR1", // 9
2564: "RBCR0", // a
2565: "RBCR1", // b
2566: "RCR", // c
2567: "TCR", // d
2568: "DCR", // e
2569: "IMR", // f
2570:
2571: "CR", // 0 Page3(Write側)
2572: "9346CR", // 1
2573: "BPAGE", // 2
2574: "CONFIG0", // 3
2575: "CONFIG1", // 4
2576: "CONFIG2", // 5
2577: "CONFIG3", // 6
2578: "TEST", // 7
2579: NULL, // 8
2580: "HLTCLK", // 9
2581: NULL, // a
2582: NULL, // b
2583: "FMWP", // c
2584: NULL, // d
2585: NULL, // e
2586: NULL, // f
2587: };
2588:
2589: // CR_RD (DMAMode) の名前を返す
2590: /*static*/ const char *
2591: RTL8019ASDevice::GetDMAName(uint32 mode)
2592: {
2593: static const char * const rd_str[] = {
2594: // 01234567890
2595: "NotAllowed",
2596: "RemoteRead",
2597: "RemoteWrite",
2598: "SendPacket",
2599: "Complt/Abrt",
2600: };
2601:
2602: if (mode > 4) {
2603: return rd_str[4];
2604: } else {
2605: return rd_str[mode];
2606: }
2607: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.